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

#if 0
#pragma makedep unix
#endif

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

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

#include "unixlib.h"
#include "unix_private.h"

#include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(opengl);

static NTSTATUS wgl_wglDeleteContext( void *args )
{
    struct wglDeleteContext_params *params = args;
    params->ret = wrap_wglDeleteContext( params->teb, params->oldContext );
    return STATUS_SUCCESS;
}

static NTSTATUS wgl_wglGetPixelFormat( void *args )
{
    struct wglGetPixelFormat_params *params = args;
    const struct opengl_funcs *funcs = get_dc_funcs( params->hdc );
    if (!funcs || !funcs->p_wglGetPixelFormat) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglGetPixelFormat( params->hdc );
    return STATUS_SUCCESS;
}

static NTSTATUS wgl_wglSetPixelFormat( void *args )
{
    struct wglSetPixelFormat_params *params = args;
    const struct opengl_funcs *funcs = get_dc_funcs( params->hdc );
    if (!funcs || !funcs->p_wglSetPixelFormat) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglSetPixelFormat( params->hdc, params->ipfd, params->ppfd );
    return STATUS_SUCCESS;
}

static NTSTATUS wgl_wglSwapBuffers( void *args )
{
    struct wglSwapBuffers_params *params = args;
    params->ret = wrap_wglSwapBuffers( params->teb, params->hdc );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glAccum( void *args )
{
    struct glAccum_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAccum) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAccum( params->op, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glAlphaFunc( void *args )
{
    struct glAlphaFunc_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAlphaFunc) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAlphaFunc( params->func, params->ref );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glAreTexturesResident( void *args )
{
    struct glAreTexturesResident_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAreTexturesResident) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glAreTexturesResident( params->n, params->textures, params->residences );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glArrayElement( void *args )
{
    struct glArrayElement_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glArrayElement) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glArrayElement( params->i );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glBegin( void *args )
{
    struct glBegin_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBegin) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBegin( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glBindTexture( void *args )
{
    struct glBindTexture_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindTexture) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindTexture( params->target, params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glBitmap( void *args )
{
    struct glBitmap_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBitmap) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBitmap( params->width, params->height, params->xorig, params->yorig, params->xmove, params->ymove, params->bitmap );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glBlendFunc( void *args )
{
    struct glBlendFunc_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendFunc) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFunc( params->sfactor, params->dfactor );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glCallList( void *args )
{
    struct glCallList_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCallList) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCallList( params->list );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glCallLists( void *args )
{
    struct glCallLists_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCallLists) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCallLists( params->n, params->type, params->lists );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glClear( void *args )
{
    struct glClear_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClear) return STATUS_NOT_IMPLEMENTED;
    wrap_glClear( params->teb, params->mask, funcs->p_glClear );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glClearAccum( void *args )
{
    struct glClearAccum_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearAccum) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearAccum( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glClearColor( void *args )
{
    struct glClearColor_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearColor) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearColor( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glClearDepth( void *args )
{
    struct glClearDepth_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearDepth) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearDepth( params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glClearIndex( void *args )
{
    struct glClearIndex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearIndex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearIndex( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glClearStencil( void *args )
{
    struct glClearStencil_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearStencil) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearStencil( params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glClipPlane( void *args )
{
    struct glClipPlane_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClipPlane) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClipPlane( params->plane, params->equation );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor3b( void *args )
{
    struct glColor3b_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3b) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3b( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor3bv( void *args )
{
    struct glColor3bv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3bv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3bv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor3d( void *args )
{
    struct glColor3d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3d( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor3dv( void *args )
{
    struct glColor3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3dv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor3f( void *args )
{
    struct glColor3f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3f( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor3fv( void *args )
{
    struct glColor3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3fv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor3i( void *args )
{
    struct glColor3i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3i( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor3iv( void *args )
{
    struct glColor3iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3iv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor3s( void *args )
{
    struct glColor3s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3s( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor3sv( void *args )
{
    struct glColor3sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3sv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor3ub( void *args )
{
    struct glColor3ub_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3ub) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3ub( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor3ubv( void *args )
{
    struct glColor3ubv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3ubv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3ubv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor3ui( void *args )
{
    struct glColor3ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3ui( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor3uiv( void *args )
{
    struct glColor3uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3uiv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor3us( void *args )
{
    struct glColor3us_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3us) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3us( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor3usv( void *args )
{
    struct glColor3usv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3usv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3usv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor4b( void *args )
{
    struct glColor4b_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4b) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4b( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor4bv( void *args )
{
    struct glColor4bv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4bv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4bv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor4d( void *args )
{
    struct glColor4d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4d( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor4dv( void *args )
{
    struct glColor4dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4dv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor4f( void *args )
{
    struct glColor4f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4f( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor4fv( void *args )
{
    struct glColor4fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4fv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor4i( void *args )
{
    struct glColor4i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4i( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor4iv( void *args )
{
    struct glColor4iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4iv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor4s( void *args )
{
    struct glColor4s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4s( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor4sv( void *args )
{
    struct glColor4sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4sv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor4ub( void *args )
{
    struct glColor4ub_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4ub) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4ub( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor4ubv( void *args )
{
    struct glColor4ubv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4ubv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4ubv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor4ui( void *args )
{
    struct glColor4ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4ui( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor4uiv( void *args )
{
    struct glColor4uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4uiv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor4us( void *args )
{
    struct glColor4us_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4us) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4us( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColor4usv( void *args )
{
    struct glColor4usv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4usv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4usv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColorMask( void *args )
{
    struct glColorMask_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorMask) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorMask( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColorMaterial( void *args )
{
    struct glColorMaterial_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorMaterial) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorMaterial( params->face, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glColorPointer( void *args )
{
    struct glColorPointer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorPointer( params->size, params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glCopyPixels( void *args )
{
    struct glCopyPixels_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyPixels) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyPixels( params->x, params->y, params->width, params->height, params->type );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glCopyTexImage1D( void *args )
{
    struct glCopyTexImage1D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTexImage1D) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyTexImage1D( params->target, params->level, params->internalformat, params->x, params->y, params->width, params->border );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glCopyTexImage2D( void *args )
{
    struct glCopyTexImage2D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTexImage2D) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyTexImage2D( params->target, params->level, params->internalformat, params->x, params->y, params->width, params->height, params->border );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glCopyTexSubImage1D( void *args )
{
    struct glCopyTexSubImage1D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTexSubImage1D) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyTexSubImage1D( params->target, params->level, params->xoffset, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glCopyTexSubImage2D( void *args )
{
    struct glCopyTexSubImage2D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTexSubImage2D) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyTexSubImage2D( params->target, params->level, params->xoffset, params->yoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glCullFace( void *args )
{
    struct glCullFace_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCullFace) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCullFace( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glDeleteLists( void *args )
{
    struct glDeleteLists_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteLists) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteLists( params->list, params->range );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glDeleteTextures( void *args )
{
    struct glDeleteTextures_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteTextures) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteTextures( params->n, params->textures );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glDepthFunc( void *args )
{
    struct glDepthFunc_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDepthFunc) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthFunc( params->func );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glDepthMask( void *args )
{
    struct glDepthMask_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDepthMask) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthMask( params->flag );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glDepthRange( void *args )
{
    struct glDepthRange_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDepthRange) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRange( params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glDisable( void *args )
{
    struct glDisable_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDisable) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisable( params->cap );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glDisableClientState( void *args )
{
    struct glDisableClientState_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDisableClientState) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableClientState( params->array );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glDrawArrays( void *args )
{
    struct glDrawArrays_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawArrays) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawArrays( params->mode, params->first, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glDrawBuffer( void *args )
{
    struct glDrawBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawBuffer) return STATUS_NOT_IMPLEMENTED;
    wrap_glDrawBuffer( params->teb, params->buf, funcs->p_glDrawBuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glDrawElements( void *args )
{
    struct glDrawElements_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawElements) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElements( params->mode, params->count, params->type, params->indices );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glDrawPixels( void *args )
{
    struct glDrawPixels_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawPixels) return STATUS_NOT_IMPLEMENTED;
    wrap_glDrawPixels( params->teb, params->width, params->height, params->format, params->type, params->pixels, funcs->p_glDrawPixels );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEdgeFlag( void *args )
{
    struct glEdgeFlag_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEdgeFlag) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEdgeFlag( params->flag );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEdgeFlagPointer( void *args )
{
    struct glEdgeFlagPointer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEdgeFlagPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEdgeFlagPointer( params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEdgeFlagv( void *args )
{
    struct glEdgeFlagv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEdgeFlagv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEdgeFlagv( params->flag );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEnable( void *args )
{
    struct glEnable_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEnable) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnable( params->cap );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEnableClientState( void *args )
{
    struct glEnableClientState_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEnableClientState) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableClientState( params->array );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEnd( void *args )
{
    struct glEnd_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEnd) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnd();
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEndList( void *args )
{
    struct glEndList_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEndList) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndList();
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEvalCoord1d( void *args )
{
    struct glEvalCoord1d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalCoord1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord1d( params->u );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEvalCoord1dv( void *args )
{
    struct glEvalCoord1dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalCoord1dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord1dv( params->u );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEvalCoord1f( void *args )
{
    struct glEvalCoord1f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalCoord1f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord1f( params->u );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEvalCoord1fv( void *args )
{
    struct glEvalCoord1fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalCoord1fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord1fv( params->u );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEvalCoord2d( void *args )
{
    struct glEvalCoord2d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalCoord2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord2d( params->u, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEvalCoord2dv( void *args )
{
    struct glEvalCoord2dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalCoord2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord2dv( params->u );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEvalCoord2f( void *args )
{
    struct glEvalCoord2f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalCoord2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord2f( params->u, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEvalCoord2fv( void *args )
{
    struct glEvalCoord2fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalCoord2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord2fv( params->u );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEvalMesh1( void *args )
{
    struct glEvalMesh1_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalMesh1) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalMesh1( params->mode, params->i1, params->i2 );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEvalMesh2( void *args )
{
    struct glEvalMesh2_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalMesh2) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalMesh2( params->mode, params->i1, params->i2, params->j1, params->j2 );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEvalPoint1( void *args )
{
    struct glEvalPoint1_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalPoint1) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalPoint1( params->i );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glEvalPoint2( void *args )
{
    struct glEvalPoint2_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalPoint2) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalPoint2( params->i, params->j );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glFeedbackBuffer( void *args )
{
    struct glFeedbackBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFeedbackBuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFeedbackBuffer( params->size, params->type, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glFinish( void *args )
{
    struct glFinish_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFinish) return STATUS_NOT_IMPLEMENTED;
    wrap_glFinish( params->teb, funcs->p_glFinish );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glFlush( void *args )
{
    struct glFlush_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFlush) return STATUS_NOT_IMPLEMENTED;
    wrap_glFlush( params->teb, funcs->p_glFlush );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glFogf( void *args )
{
    struct glFogf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogf( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glFogfv( void *args )
{
    struct glFogfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogfv( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glFogi( void *args )
{
    struct glFogi_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogi) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogi( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glFogiv( void *args )
{
    struct glFogiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogiv( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glFrontFace( void *args )
{
    struct glFrontFace_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFrontFace) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFrontFace( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glFrustum( void *args )
{
    struct glFrustum_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFrustum) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFrustum( params->left, params->right, params->bottom, params->top, params->zNear, params->zFar );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGenLists( void *args )
{
    struct glGenLists_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenLists) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGenLists( params->range );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGenTextures( void *args )
{
    struct glGenTextures_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenTextures) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenTextures( params->n, params->textures );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetBooleanv( void *args )
{
    struct glGetBooleanv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetBooleanv) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetBooleanv( params->teb, params->pname, params->data, funcs->p_glGetBooleanv );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetClipPlane( void *args )
{
    struct glGetClipPlane_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetClipPlane) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetClipPlane( params->plane, params->equation );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetDoublev( void *args )
{
    struct glGetDoublev_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetDoublev) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetDoublev( params->teb, params->pname, params->data, funcs->p_glGetDoublev );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetError( void *args )
{
    struct glGetError_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetError) return STATUS_NOT_IMPLEMENTED;
    params->ret = wrap_glGetError( params->teb, funcs->p_glGetError );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetFloatv( void *args )
{
    struct glGetFloatv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFloatv) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetFloatv( params->teb, params->pname, params->data, funcs->p_glGetFloatv );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetIntegerv( void *args )
{
    struct glGetIntegerv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetIntegerv) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetIntegerv( params->teb, params->pname, params->data, funcs->p_glGetIntegerv );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetLightfv( void *args )
{
    struct glGetLightfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetLightfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetLightfv( params->light, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetLightiv( void *args )
{
    struct glGetLightiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetLightiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetLightiv( params->light, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetMapdv( void *args )
{
    struct glGetMapdv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMapdv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapdv( params->target, params->query, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetMapfv( void *args )
{
    struct glGetMapfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMapfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapfv( params->target, params->query, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetMapiv( void *args )
{
    struct glGetMapiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMapiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapiv( params->target, params->query, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetMaterialfv( void *args )
{
    struct glGetMaterialfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMaterialfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMaterialfv( params->face, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetMaterialiv( void *args )
{
    struct glGetMaterialiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMaterialiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMaterialiv( params->face, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetPixelMapfv( void *args )
{
    struct glGetPixelMapfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPixelMapfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPixelMapfv( params->map, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetPixelMapuiv( void *args )
{
    struct glGetPixelMapuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPixelMapuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPixelMapuiv( params->map, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetPixelMapusv( void *args )
{
    struct glGetPixelMapusv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPixelMapusv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPixelMapusv( params->map, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetPointerv( void *args )
{
    struct glGetPointerv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPointerv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPointerv( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetPolygonStipple( void *args )
{
    struct glGetPolygonStipple_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPolygonStipple) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPolygonStipple( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetString( void *args )
{
    struct glGetString_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetString) return STATUS_NOT_IMPLEMENTED;
    params->ret = wrap_glGetString( params->teb, params->name, funcs->p_glGetString );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetTexEnvfv( void *args )
{
    struct glGetTexEnvfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexEnvfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexEnvfv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetTexEnviv( void *args )
{
    struct glGetTexEnviv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexEnviv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexEnviv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetTexGendv( void *args )
{
    struct glGetTexGendv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexGendv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexGendv( params->coord, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetTexGenfv( void *args )
{
    struct glGetTexGenfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexGenfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexGenfv( params->coord, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetTexGeniv( void *args )
{
    struct glGetTexGeniv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexGeniv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexGeniv( params->coord, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetTexImage( void *args )
{
    struct glGetTexImage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexImage( params->target, params->level, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetTexLevelParameterfv( void *args )
{
    struct glGetTexLevelParameterfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexLevelParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexLevelParameterfv( params->target, params->level, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetTexLevelParameteriv( void *args )
{
    struct glGetTexLevelParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexLevelParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexLevelParameteriv( params->target, params->level, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetTexParameterfv( void *args )
{
    struct glGetTexParameterfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameterfv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glGetTexParameteriv( void *args )
{
    struct glGetTexParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameteriv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glHint( void *args )
{
    struct glHint_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glHint) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glHint( params->target, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glIndexMask( void *args )
{
    struct glIndexMask_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexMask) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexMask( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glIndexPointer( void *args )
{
    struct glIndexPointer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexPointer( params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glIndexd( void *args )
{
    struct glIndexd_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexd) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexd( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glIndexdv( void *args )
{
    struct glIndexdv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexdv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexdv( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glIndexf( void *args )
{
    struct glIndexf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexf( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glIndexfv( void *args )
{
    struct glIndexfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexfv( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glIndexi( void *args )
{
    struct glIndexi_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexi) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexi( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glIndexiv( void *args )
{
    struct glIndexiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexiv( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glIndexs( void *args )
{
    struct glIndexs_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexs) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexs( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glIndexsv( void *args )
{
    struct glIndexsv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexsv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexsv( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glIndexub( void *args )
{
    struct glIndexub_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexub) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexub( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glIndexubv( void *args )
{
    struct glIndexubv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexubv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexubv( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glInitNames( void *args )
{
    struct glInitNames_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glInitNames) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInitNames();
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glInterleavedArrays( void *args )
{
    struct glInterleavedArrays_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glInterleavedArrays) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInterleavedArrays( params->format, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glIsEnabled( void *args )
{
    struct glIsEnabled_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsEnabled) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsEnabled( params->cap );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glIsList( void *args )
{
    struct glIsList_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsList) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsList( params->list );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glIsTexture( void *args )
{
    struct glIsTexture_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsTexture) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsTexture( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glLightModelf( void *args )
{
    struct glLightModelf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLightModelf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightModelf( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glLightModelfv( void *args )
{
    struct glLightModelfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLightModelfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightModelfv( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glLightModeli( void *args )
{
    struct glLightModeli_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLightModeli) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightModeli( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glLightModeliv( void *args )
{
    struct glLightModeliv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLightModeliv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightModeliv( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glLightf( void *args )
{
    struct glLightf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLightf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightf( params->light, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glLightfv( void *args )
{
    struct glLightfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLightfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightfv( params->light, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glLighti( void *args )
{
    struct glLighti_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLighti) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLighti( params->light, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glLightiv( void *args )
{
    struct glLightiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLightiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightiv( params->light, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glLineStipple( void *args )
{
    struct glLineStipple_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLineStipple) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLineStipple( params->factor, params->pattern );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glLineWidth( void *args )
{
    struct glLineWidth_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLineWidth) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLineWidth( params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glListBase( void *args )
{
    struct glListBase_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glListBase) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glListBase( params->base );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glLoadIdentity( void *args )
{
    struct glLoadIdentity_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLoadIdentity) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadIdentity();
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glLoadMatrixd( void *args )
{
    struct glLoadMatrixd_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLoadMatrixd) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadMatrixd( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glLoadMatrixf( void *args )
{
    struct glLoadMatrixf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLoadMatrixf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadMatrixf( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glLoadName( void *args )
{
    struct glLoadName_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLoadName) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadName( params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glLogicOp( void *args )
{
    struct glLogicOp_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLogicOp) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLogicOp( params->opcode );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glMap1d( void *args )
{
    struct glMap1d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMap1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMap1d( params->target, params->u1, params->u2, params->stride, params->order, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glMap1f( void *args )
{
    struct glMap1f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMap1f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMap1f( params->target, params->u1, params->u2, params->stride, params->order, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glMap2d( void *args )
{
    struct glMap2d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMap2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMap2d( params->target, params->u1, params->u2, params->ustride, params->uorder, params->v1, params->v2, params->vstride, params->vorder, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glMap2f( void *args )
{
    struct glMap2f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMap2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMap2f( params->target, params->u1, params->u2, params->ustride, params->uorder, params->v1, params->v2, params->vstride, params->vorder, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glMapGrid1d( void *args )
{
    struct glMapGrid1d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapGrid1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapGrid1d( params->un, params->u1, params->u2 );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glMapGrid1f( void *args )
{
    struct glMapGrid1f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapGrid1f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapGrid1f( params->un, params->u1, params->u2 );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glMapGrid2d( void *args )
{
    struct glMapGrid2d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapGrid2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapGrid2d( params->un, params->u1, params->u2, params->vn, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glMapGrid2f( void *args )
{
    struct glMapGrid2f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapGrid2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapGrid2f( params->un, params->u1, params->u2, params->vn, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glMaterialf( void *args )
{
    struct glMaterialf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMaterialf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaterialf( params->face, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glMaterialfv( void *args )
{
    struct glMaterialfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMaterialfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaterialfv( params->face, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glMateriali( void *args )
{
    struct glMateriali_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMateriali) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMateriali( params->face, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glMaterialiv( void *args )
{
    struct glMaterialiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMaterialiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaterialiv( params->face, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glMatrixMode( void *args )
{
    struct glMatrixMode_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixMode) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixMode( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glMultMatrixd( void *args )
{
    struct glMultMatrixd_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultMatrixd) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultMatrixd( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glMultMatrixf( void *args )
{
    struct glMultMatrixf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultMatrixf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultMatrixf( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glNewList( void *args )
{
    struct glNewList_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNewList) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNewList( params->list, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glNormal3b( void *args )
{
    struct glNormal3b_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3b) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3b( params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glNormal3bv( void *args )
{
    struct glNormal3bv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3bv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3bv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glNormal3d( void *args )
{
    struct glNormal3d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3d( params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glNormal3dv( void *args )
{
    struct glNormal3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3dv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glNormal3f( void *args )
{
    struct glNormal3f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3f( params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glNormal3fv( void *args )
{
    struct glNormal3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3fv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glNormal3i( void *args )
{
    struct glNormal3i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3i( params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glNormal3iv( void *args )
{
    struct glNormal3iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3iv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glNormal3s( void *args )
{
    struct glNormal3s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3s( params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glNormal3sv( void *args )
{
    struct glNormal3sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3sv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glNormalPointer( void *args )
{
    struct glNormalPointer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalPointer( params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glOrtho( void *args )
{
    struct glOrtho_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glOrtho) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glOrtho( params->left, params->right, params->bottom, params->top, params->zNear, params->zFar );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPassThrough( void *args )
{
    struct glPassThrough_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPassThrough) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPassThrough( params->token );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPixelMapfv( void *args )
{
    struct glPixelMapfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelMapfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelMapfv( params->map, params->mapsize, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPixelMapuiv( void *args )
{
    struct glPixelMapuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelMapuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelMapuiv( params->map, params->mapsize, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPixelMapusv( void *args )
{
    struct glPixelMapusv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelMapusv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelMapusv( params->map, params->mapsize, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPixelStoref( void *args )
{
    struct glPixelStoref_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelStoref) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelStoref( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPixelStorei( void *args )
{
    struct glPixelStorei_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelStorei) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelStorei( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPixelTransferf( void *args )
{
    struct glPixelTransferf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelTransferf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTransferf( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPixelTransferi( void *args )
{
    struct glPixelTransferi_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelTransferi) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTransferi( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPixelZoom( void *args )
{
    struct glPixelZoom_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelZoom) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelZoom( params->xfactor, params->yfactor );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPointSize( void *args )
{
    struct glPointSize_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointSize) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointSize( params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPolygonMode( void *args )
{
    struct glPolygonMode_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPolygonMode) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPolygonMode( params->face, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPolygonOffset( void *args )
{
    struct glPolygonOffset_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPolygonOffset) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPolygonOffset( params->factor, params->units );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPolygonStipple( void *args )
{
    struct glPolygonStipple_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPolygonStipple) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPolygonStipple( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPopAttrib( void *args )
{
    struct glPopAttrib_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPopAttrib) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPopAttrib();
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPopClientAttrib( void *args )
{
    struct glPopClientAttrib_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPopClientAttrib) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPopClientAttrib();
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPopMatrix( void *args )
{
    struct glPopMatrix_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPopMatrix) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPopMatrix();
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPopName( void *args )
{
    struct glPopName_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPopName) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPopName();
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPrioritizeTextures( void *args )
{
    struct glPrioritizeTextures_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPrioritizeTextures) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPrioritizeTextures( params->n, params->textures, params->priorities );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPushAttrib( void *args )
{
    struct glPushAttrib_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPushAttrib) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPushAttrib( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPushClientAttrib( void *args )
{
    struct glPushClientAttrib_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPushClientAttrib) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPushClientAttrib( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPushMatrix( void *args )
{
    struct glPushMatrix_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPushMatrix) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPushMatrix();
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glPushName( void *args )
{
    struct glPushName_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPushName) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPushName( params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos2d( void *args )
{
    struct glRasterPos2d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2d( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos2dv( void *args )
{
    struct glRasterPos2dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2dv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos2f( void *args )
{
    struct glRasterPos2f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2f( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos2fv( void *args )
{
    struct glRasterPos2fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2fv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos2i( void *args )
{
    struct glRasterPos2i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos2i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2i( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos2iv( void *args )
{
    struct glRasterPos2iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos2iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2iv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos2s( void *args )
{
    struct glRasterPos2s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos2s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2s( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos2sv( void *args )
{
    struct glRasterPos2sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos2sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2sv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos3d( void *args )
{
    struct glRasterPos3d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3d( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos3dv( void *args )
{
    struct glRasterPos3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3dv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos3f( void *args )
{
    struct glRasterPos3f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3f( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos3fv( void *args )
{
    struct glRasterPos3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3fv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos3i( void *args )
{
    struct glRasterPos3i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3i( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos3iv( void *args )
{
    struct glRasterPos3iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3iv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos3s( void *args )
{
    struct glRasterPos3s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3s( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos3sv( void *args )
{
    struct glRasterPos3sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3sv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos4d( void *args )
{
    struct glRasterPos4d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4d( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos4dv( void *args )
{
    struct glRasterPos4dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4dv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos4f( void *args )
{
    struct glRasterPos4f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos4f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4f( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos4fv( void *args )
{
    struct glRasterPos4fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4fv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos4i( void *args )
{
    struct glRasterPos4i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos4i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4i( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos4iv( void *args )
{
    struct glRasterPos4iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4iv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos4s( void *args )
{
    struct glRasterPos4s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos4s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4s( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRasterPos4sv( void *args )
{
    struct glRasterPos4sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos4sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4sv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glReadBuffer( void *args )
{
    struct glReadBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReadBuffer) return STATUS_NOT_IMPLEMENTED;
    wrap_glReadBuffer( params->teb, params->src, funcs->p_glReadBuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glReadPixels( void *args )
{
    struct glReadPixels_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReadPixels) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    wrap_glReadPixels( params->teb, params->x, params->y, params->width, params->height, params->format, params->type, params->pixels, funcs->p_glReadPixels );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRectd( void *args )
{
    struct glRectd_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRectd) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRectd( params->x1, params->y1, params->x2, params->y2 );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRectdv( void *args )
{
    struct glRectdv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRectdv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRectdv( params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRectf( void *args )
{
    struct glRectf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRectf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRectf( params->x1, params->y1, params->x2, params->y2 );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRectfv( void *args )
{
    struct glRectfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRectfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRectfv( params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRecti( void *args )
{
    struct glRecti_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRecti) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRecti( params->x1, params->y1, params->x2, params->y2 );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRectiv( void *args )
{
    struct glRectiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRectiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRectiv( params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRects( void *args )
{
    struct glRects_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRects) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRects( params->x1, params->y1, params->x2, params->y2 );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRectsv( void *args )
{
    struct glRectsv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRectsv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRectsv( params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRenderMode( void *args )
{
    struct glRenderMode_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRenderMode) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glRenderMode( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRotated( void *args )
{
    struct glRotated_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRotated) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRotated( params->angle, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glRotatef( void *args )
{
    struct glRotatef_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRotatef) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRotatef( params->angle, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glScaled( void *args )
{
    struct glScaled_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glScaled) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScaled( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glScalef( void *args )
{
    struct glScalef_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glScalef) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScalef( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glScissor( void *args )
{
    struct glScissor_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glScissor) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScissor( params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glSelectBuffer( void *args )
{
    struct glSelectBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSelectBuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSelectBuffer( params->size, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glShadeModel( void *args )
{
    struct glShadeModel_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glShadeModel) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShadeModel( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glStencilFunc( void *args )
{
    struct glStencilFunc_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilFunc) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilFunc( params->func, params->ref, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glStencilMask( void *args )
{
    struct glStencilMask_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilMask) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilMask( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glStencilOp( void *args )
{
    struct glStencilOp_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilOp) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilOp( params->fail, params->zfail, params->zpass );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord1d( void *args )
{
    struct glTexCoord1d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1d( params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord1dv( void *args )
{
    struct glTexCoord1dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord1dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1dv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord1f( void *args )
{
    struct glTexCoord1f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord1f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1f( params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord1fv( void *args )
{
    struct glTexCoord1fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord1fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1fv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord1i( void *args )
{
    struct glTexCoord1i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord1i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1i( params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord1iv( void *args )
{
    struct glTexCoord1iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord1iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1iv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord1s( void *args )
{
    struct glTexCoord1s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord1s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1s( params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord1sv( void *args )
{
    struct glTexCoord1sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord1sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1sv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord2d( void *args )
{
    struct glTexCoord2d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2d( params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord2dv( void *args )
{
    struct glTexCoord2dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2dv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord2f( void *args )
{
    struct glTexCoord2f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2f( params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord2fv( void *args )
{
    struct glTexCoord2fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord2i( void *args )
{
    struct glTexCoord2i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2i( params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord2iv( void *args )
{
    struct glTexCoord2iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2iv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord2s( void *args )
{
    struct glTexCoord2s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2s( params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord2sv( void *args )
{
    struct glTexCoord2sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2sv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord3d( void *args )
{
    struct glTexCoord3d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3d( params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord3dv( void *args )
{
    struct glTexCoord3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3dv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord3f( void *args )
{
    struct glTexCoord3f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3f( params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord3fv( void *args )
{
    struct glTexCoord3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3fv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord3i( void *args )
{
    struct glTexCoord3i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3i( params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord3iv( void *args )
{
    struct glTexCoord3iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3iv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord3s( void *args )
{
    struct glTexCoord3s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3s( params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord3sv( void *args )
{
    struct glTexCoord3sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3sv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord4d( void *args )
{
    struct glTexCoord4d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4d( params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord4dv( void *args )
{
    struct glTexCoord4dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4dv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord4f( void *args )
{
    struct glTexCoord4f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4f( params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord4fv( void *args )
{
    struct glTexCoord4fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4fv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord4i( void *args )
{
    struct glTexCoord4i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4i( params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord4iv( void *args )
{
    struct glTexCoord4iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4iv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord4s( void *args )
{
    struct glTexCoord4s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4s( params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoord4sv( void *args )
{
    struct glTexCoord4sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4sv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexCoordPointer( void *args )
{
    struct glTexCoordPointer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoordPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordPointer( params->size, params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexEnvf( void *args )
{
    struct glTexEnvf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexEnvf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexEnvf( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexEnvfv( void *args )
{
    struct glTexEnvfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexEnvfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexEnvfv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexEnvi( void *args )
{
    struct glTexEnvi_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexEnvi) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexEnvi( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexEnviv( void *args )
{
    struct glTexEnviv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexEnviv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexEnviv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexGend( void *args )
{
    struct glTexGend_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexGend) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexGend( params->coord, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexGendv( void *args )
{
    struct glTexGendv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexGendv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexGendv( params->coord, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexGenf( void *args )
{
    struct glTexGenf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexGenf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexGenf( params->coord, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexGenfv( void *args )
{
    struct glTexGenfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexGenfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexGenfv( params->coord, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexGeni( void *args )
{
    struct glTexGeni_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexGeni) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexGeni( params->coord, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexGeniv( void *args )
{
    struct glTexGeniv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexGeniv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexGeniv( params->coord, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexImage1D( void *args )
{
    struct glTexImage1D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexImage1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage1D( params->target, params->level, params->internalformat, params->width, params->border, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexImage2D( void *args )
{
    struct glTexImage2D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexImage2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage2D( params->target, params->level, params->internalformat, params->width, params->height, params->border, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexParameterf( void *args )
{
    struct glTexParameterf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexParameterf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterf( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexParameterfv( void *args )
{
    struct glTexParameterfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterfv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexParameteri( void *args )
{
    struct glTexParameteri_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexParameteri) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameteri( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexParameteriv( void *args )
{
    struct glTexParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameteriv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexSubImage1D( void *args )
{
    struct glTexSubImage1D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexSubImage1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexSubImage1D( params->target, params->level, params->xoffset, params->width, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTexSubImage2D( void *args )
{
    struct glTexSubImage2D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexSubImage2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexSubImage2D( params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTranslated( void *args )
{
    struct glTranslated_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTranslated) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTranslated( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glTranslatef( void *args )
{
    struct glTranslatef_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTranslatef) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTranslatef( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex2d( void *args )
{
    struct glVertex2d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2d( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex2dv( void *args )
{
    struct glVertex2dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2dv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex2f( void *args )
{
    struct glVertex2f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2f( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex2fv( void *args )
{
    struct glVertex2fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2fv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex2i( void *args )
{
    struct glVertex2i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex2i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2i( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex2iv( void *args )
{
    struct glVertex2iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex2iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2iv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex2s( void *args )
{
    struct glVertex2s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex2s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2s( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex2sv( void *args )
{
    struct glVertex2sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex2sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2sv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex3d( void *args )
{
    struct glVertex3d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3d( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex3dv( void *args )
{
    struct glVertex3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3dv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex3f( void *args )
{
    struct glVertex3f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3f( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex3fv( void *args )
{
    struct glVertex3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3fv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex3i( void *args )
{
    struct glVertex3i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3i( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex3iv( void *args )
{
    struct glVertex3iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3iv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex3s( void *args )
{
    struct glVertex3s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3s( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex3sv( void *args )
{
    struct glVertex3sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3sv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex4d( void *args )
{
    struct glVertex4d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4d( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex4dv( void *args )
{
    struct glVertex4dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4dv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex4f( void *args )
{
    struct glVertex4f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex4f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4f( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex4fv( void *args )
{
    struct glVertex4fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4fv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex4i( void *args )
{
    struct glVertex4i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex4i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4i( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex4iv( void *args )
{
    struct glVertex4iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4iv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex4s( void *args )
{
    struct glVertex4s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex4s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4s( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertex4sv( void *args )
{
    struct glVertex4sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex4sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4sv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glVertexPointer( void *args )
{
    struct glVertexPointer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexPointer( params->size, params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS gl_glViewport( void *args )
{
    struct glViewport_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glViewport) return STATUS_NOT_IMPLEMENTED;
    wrap_glViewport( params->teb, params->x, params->y, params->width, params->height, funcs->p_glViewport );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glAccumxOES( void *args )
{
    struct glAccumxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAccumxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAccumxOES( params->op, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glAcquireKeyedMutexWin32EXT( void *args )
{
    struct glAcquireKeyedMutexWin32EXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAcquireKeyedMutexWin32EXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glAcquireKeyedMutexWin32EXT( params->memory, params->key, params->timeout );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glActiveProgramEXT( void *args )
{
    struct glActiveProgramEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glActiveProgramEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glActiveProgramEXT( params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glActiveShaderProgram( void *args )
{
    struct glActiveShaderProgram_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glActiveShaderProgram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glActiveShaderProgram( params->pipeline, params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glActiveStencilFaceEXT( void *args )
{
    struct glActiveStencilFaceEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glActiveStencilFaceEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glActiveStencilFaceEXT( params->face );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glActiveTexture( void *args )
{
    struct glActiveTexture_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glActiveTexture) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glActiveTexture( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glActiveTextureARB( void *args )
{
    struct glActiveTextureARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glActiveTextureARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glActiveTextureARB( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glActiveVaryingNV( void *args )
{
    struct glActiveVaryingNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glActiveVaryingNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glActiveVaryingNV( params->program, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glAlphaFragmentOp1ATI( void *args )
{
    struct glAlphaFragmentOp1ATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAlphaFragmentOp1ATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAlphaFragmentOp1ATI( params->op, params->dst, params->dstMod, params->arg1, params->arg1Rep, params->arg1Mod );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glAlphaFragmentOp2ATI( void *args )
{
    struct glAlphaFragmentOp2ATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAlphaFragmentOp2ATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAlphaFragmentOp2ATI( params->op, params->dst, params->dstMod, params->arg1, params->arg1Rep, params->arg1Mod, params->arg2, params->arg2Rep, params->arg2Mod );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glAlphaFragmentOp3ATI( void *args )
{
    struct glAlphaFragmentOp3ATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAlphaFragmentOp3ATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAlphaFragmentOp3ATI( params->op, params->dst, params->dstMod, params->arg1, params->arg1Rep, params->arg1Mod, params->arg2, params->arg2Rep, params->arg2Mod, params->arg3, params->arg3Rep, params->arg3Mod );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glAlphaFuncx( void *args )
{
    struct glAlphaFuncx_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAlphaFuncx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAlphaFuncx( params->func, params->ref );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glAlphaFuncxOES( void *args )
{
    struct glAlphaFuncxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAlphaFuncxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAlphaFuncxOES( params->func, params->ref );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glAlphaToCoverageDitherControlNV( void *args )
{
    struct glAlphaToCoverageDitherControlNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAlphaToCoverageDitherControlNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAlphaToCoverageDitherControlNV( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glApplyFramebufferAttachmentCMAAINTEL( void *args )
{
    struct glApplyFramebufferAttachmentCMAAINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glApplyFramebufferAttachmentCMAAINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glApplyFramebufferAttachmentCMAAINTEL();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glApplyTextureEXT( void *args )
{
    struct glApplyTextureEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glApplyTextureEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glApplyTextureEXT( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glAreProgramsResidentNV( void *args )
{
    struct glAreProgramsResidentNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAreProgramsResidentNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glAreProgramsResidentNV( params->n, params->programs, params->residences );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glAreTexturesResidentEXT( void *args )
{
    struct glAreTexturesResidentEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAreTexturesResidentEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glAreTexturesResidentEXT( params->n, params->textures, params->residences );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glArrayElementEXT( void *args )
{
    struct glArrayElementEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glArrayElementEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glArrayElementEXT( params->i );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glArrayObjectATI( void *args )
{
    struct glArrayObjectATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glArrayObjectATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glArrayObjectATI( params->array, params->size, params->type, params->stride, params->buffer, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glAsyncCopyBufferSubDataNVX( void *args )
{
    struct glAsyncCopyBufferSubDataNVX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAsyncCopyBufferSubDataNVX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glAsyncCopyBufferSubDataNVX( params->waitSemaphoreCount, params->waitSemaphoreArray, params->fenceValueArray, params->readGpu, params->writeGpuMask, params->readBuffer, params->writeBuffer, params->readOffset, params->writeOffset, params->size, params->signalSemaphoreCount, params->signalSemaphoreArray, params->signalValueArray );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glAsyncCopyImageSubDataNVX( void *args )
{
    struct glAsyncCopyImageSubDataNVX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAsyncCopyImageSubDataNVX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glAsyncCopyImageSubDataNVX( params->waitSemaphoreCount, params->waitSemaphoreArray, params->waitValueArray, params->srcGpu, params->dstGpuMask, params->srcName, params->srcTarget, params->srcLevel, params->srcX, params->srcY, params->srcZ, params->dstName, params->dstTarget, params->dstLevel, params->dstX, params->dstY, params->dstZ, params->srcWidth, params->srcHeight, params->srcDepth, params->signalSemaphoreCount, params->signalSemaphoreArray, params->signalValueArray );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glAsyncMarkerSGIX( void *args )
{
    struct glAsyncMarkerSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAsyncMarkerSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAsyncMarkerSGIX( params->marker );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glAttachObjectARB( void *args )
{
    struct glAttachObjectARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAttachObjectARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAttachObjectARB( params->containerObj, params->obj );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glAttachShader( void *args )
{
    struct glAttachShader_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glAttachShader) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAttachShader( params->program, params->shader );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBeginConditionalRender( void *args )
{
    struct glBeginConditionalRender_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBeginConditionalRender) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginConditionalRender( params->id, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBeginConditionalRenderNV( void *args )
{
    struct glBeginConditionalRenderNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBeginConditionalRenderNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginConditionalRenderNV( params->id, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBeginConditionalRenderNVX( void *args )
{
    struct glBeginConditionalRenderNVX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBeginConditionalRenderNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginConditionalRenderNVX( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBeginFragmentShaderATI( void *args )
{
    struct glBeginFragmentShaderATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBeginFragmentShaderATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginFragmentShaderATI();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBeginOcclusionQueryNV( void *args )
{
    struct glBeginOcclusionQueryNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBeginOcclusionQueryNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginOcclusionQueryNV( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBeginPerfMonitorAMD( void *args )
{
    struct glBeginPerfMonitorAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBeginPerfMonitorAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginPerfMonitorAMD( params->monitor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBeginPerfQueryINTEL( void *args )
{
    struct glBeginPerfQueryINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBeginPerfQueryINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginPerfQueryINTEL( params->queryHandle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBeginQuery( void *args )
{
    struct glBeginQuery_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBeginQuery) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginQuery( params->target, params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBeginQueryARB( void *args )
{
    struct glBeginQueryARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBeginQueryARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginQueryARB( params->target, params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBeginQueryIndexed( void *args )
{
    struct glBeginQueryIndexed_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBeginQueryIndexed) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginQueryIndexed( params->target, params->index, params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBeginTransformFeedback( void *args )
{
    struct glBeginTransformFeedback_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBeginTransformFeedback) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginTransformFeedback( params->primitiveMode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBeginTransformFeedbackEXT( void *args )
{
    struct glBeginTransformFeedbackEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBeginTransformFeedbackEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginTransformFeedbackEXT( params->primitiveMode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBeginTransformFeedbackNV( void *args )
{
    struct glBeginTransformFeedbackNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBeginTransformFeedbackNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginTransformFeedbackNV( params->primitiveMode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBeginVertexShaderEXT( void *args )
{
    struct glBeginVertexShaderEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBeginVertexShaderEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginVertexShaderEXT();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBeginVideoCaptureNV( void *args )
{
    struct glBeginVideoCaptureNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBeginVideoCaptureNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginVideoCaptureNV( params->video_capture_slot );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindAttribLocation( void *args )
{
    struct glBindAttribLocation_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindAttribLocation) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindAttribLocation( params->program, params->index, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindAttribLocationARB( void *args )
{
    struct glBindAttribLocationARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindAttribLocationARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindAttribLocationARB( params->programObj, params->index, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindBuffer( void *args )
{
    struct glBindBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindBuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBuffer( params->target, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindBufferARB( void *args )
{
    struct glBindBufferARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindBufferARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferARB( params->target, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindBufferBase( void *args )
{
    struct glBindBufferBase_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindBufferBase) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferBase( params->target, params->index, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindBufferBaseEXT( void *args )
{
    struct glBindBufferBaseEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindBufferBaseEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferBaseEXT( params->target, params->index, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindBufferBaseNV( void *args )
{
    struct glBindBufferBaseNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindBufferBaseNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferBaseNV( params->target, params->index, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindBufferOffsetEXT( void *args )
{
    struct glBindBufferOffsetEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindBufferOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferOffsetEXT( params->target, params->index, params->buffer, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindBufferOffsetNV( void *args )
{
    struct glBindBufferOffsetNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindBufferOffsetNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferOffsetNV( params->target, params->index, params->buffer, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindBufferRange( void *args )
{
    struct glBindBufferRange_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindBufferRange) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferRange( params->target, params->index, params->buffer, params->offset, params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindBufferRangeEXT( void *args )
{
    struct glBindBufferRangeEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindBufferRangeEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferRangeEXT( params->target, params->index, params->buffer, params->offset, params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindBufferRangeNV( void *args )
{
    struct glBindBufferRangeNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindBufferRangeNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferRangeNV( params->target, params->index, params->buffer, params->offset, params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindBuffersBase( void *args )
{
    struct glBindBuffersBase_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindBuffersBase) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBuffersBase( params->target, params->first, params->count, params->buffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindBuffersRange( void *args )
{
    struct glBindBuffersRange_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindBuffersRange) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBuffersRange( params->target, params->first, params->count, params->buffers, params->offsets, params->sizes );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindFragDataLocation( void *args )
{
    struct glBindFragDataLocation_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindFragDataLocation) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindFragDataLocation( params->program, params->color, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindFragDataLocationEXT( void *args )
{
    struct glBindFragDataLocationEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindFragDataLocationEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindFragDataLocationEXT( params->program, params->color, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindFragDataLocationIndexed( void *args )
{
    struct glBindFragDataLocationIndexed_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindFragDataLocationIndexed) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindFragDataLocationIndexed( params->program, params->colorNumber, params->index, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindFragmentShaderATI( void *args )
{
    struct glBindFragmentShaderATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindFragmentShaderATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindFragmentShaderATI( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindFramebuffer( void *args )
{
    struct glBindFramebuffer_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindFramebuffer) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, params->target );
    funcs->p_glBindFramebuffer( params->target, framebuffer );
    set_current_fbo( params->teb, params->target, params->framebuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindFramebufferEXT( void *args )
{
    struct glBindFramebufferEXT_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindFramebufferEXT) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, params->target );
    funcs->p_glBindFramebufferEXT( params->target, framebuffer );
    set_current_fbo( params->teb, params->target, params->framebuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindImageTexture( void *args )
{
    struct glBindImageTexture_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindImageTexture) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindImageTexture( params->unit, params->texture, params->level, params->layered, params->layer, params->access, params->format );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindImageTextureEXT( void *args )
{
    struct glBindImageTextureEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindImageTextureEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindImageTextureEXT( params->index, params->texture, params->level, params->layered, params->layer, params->access, params->format );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindImageTextures( void *args )
{
    struct glBindImageTextures_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindImageTextures) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindImageTextures( params->first, params->count, params->textures );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindLightParameterEXT( void *args )
{
    struct glBindLightParameterEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindLightParameterEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glBindLightParameterEXT( params->light, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindMaterialParameterEXT( void *args )
{
    struct glBindMaterialParameterEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindMaterialParameterEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glBindMaterialParameterEXT( params->face, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindMultiTextureEXT( void *args )
{
    struct glBindMultiTextureEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindMultiTextureEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindMultiTextureEXT( params->texunit, params->target, params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindParameterEXT( void *args )
{
    struct glBindParameterEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindParameterEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glBindParameterEXT( params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindProgramARB( void *args )
{
    struct glBindProgramARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindProgramARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindProgramARB( params->target, params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindProgramNV( void *args )
{
    struct glBindProgramNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindProgramNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindProgramNV( params->target, params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindProgramPipeline( void *args )
{
    struct glBindProgramPipeline_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindProgramPipeline) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindProgramPipeline( params->pipeline );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindRenderbuffer( void *args )
{
    struct glBindRenderbuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindRenderbuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindRenderbuffer( params->target, params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindRenderbufferEXT( void *args )
{
    struct glBindRenderbufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindRenderbufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindRenderbufferEXT( params->target, params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindSampler( void *args )
{
    struct glBindSampler_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindSampler) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindSampler( params->unit, params->sampler );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindSamplers( void *args )
{
    struct glBindSamplers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindSamplers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindSamplers( params->first, params->count, params->samplers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindShadingRateImageNV( void *args )
{
    struct glBindShadingRateImageNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindShadingRateImageNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindShadingRateImageNV( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindTexGenParameterEXT( void *args )
{
    struct glBindTexGenParameterEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindTexGenParameterEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glBindTexGenParameterEXT( params->unit, params->coord, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindTextureEXT( void *args )
{
    struct glBindTextureEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindTextureEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindTextureEXT( params->target, params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindTextureUnit( void *args )
{
    struct glBindTextureUnit_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindTextureUnit) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindTextureUnit( params->unit, params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindTextureUnitParameterEXT( void *args )
{
    struct glBindTextureUnitParameterEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindTextureUnitParameterEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glBindTextureUnitParameterEXT( params->unit, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindTextures( void *args )
{
    struct glBindTextures_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindTextures) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindTextures( params->first, params->count, params->textures );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindTransformFeedback( void *args )
{
    struct glBindTransformFeedback_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindTransformFeedback) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindTransformFeedback( params->target, params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindTransformFeedbackNV( void *args )
{
    struct glBindTransformFeedbackNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindTransformFeedbackNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindTransformFeedbackNV( params->target, params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindVertexArray( void *args )
{
    struct glBindVertexArray_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindVertexArray) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindVertexArray( params->array );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindVertexArrayAPPLE( void *args )
{
    struct glBindVertexArrayAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindVertexArrayAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindVertexArrayAPPLE( params->array );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindVertexBuffer( void *args )
{
    struct glBindVertexBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindVertexBuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindVertexBuffer( params->bindingindex, params->buffer, params->offset, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindVertexBuffers( void *args )
{
    struct glBindVertexBuffers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindVertexBuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindVertexBuffers( params->first, params->count, params->buffers, params->offsets, params->strides );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindVertexShaderEXT( void *args )
{
    struct glBindVertexShaderEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindVertexShaderEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindVertexShaderEXT( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindVideoCaptureStreamBufferNV( void *args )
{
    struct glBindVideoCaptureStreamBufferNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindVideoCaptureStreamBufferNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindVideoCaptureStreamBufferNV( params->video_capture_slot, params->stream, params->frame_region, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBindVideoCaptureStreamTextureNV( void *args )
{
    struct glBindVideoCaptureStreamTextureNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBindVideoCaptureStreamTextureNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindVideoCaptureStreamTextureNV( params->video_capture_slot, params->stream, params->frame_region, params->target, params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBinormal3bEXT( void *args )
{
    struct glBinormal3bEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBinormal3bEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3bEXT( params->bx, params->by, params->bz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBinormal3bvEXT( void *args )
{
    struct glBinormal3bvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBinormal3bvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3bvEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBinormal3dEXT( void *args )
{
    struct glBinormal3dEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBinormal3dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3dEXT( params->bx, params->by, params->bz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBinormal3dvEXT( void *args )
{
    struct glBinormal3dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBinormal3dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3dvEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBinormal3fEXT( void *args )
{
    struct glBinormal3fEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBinormal3fEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3fEXT( params->bx, params->by, params->bz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBinormal3fvEXT( void *args )
{
    struct glBinormal3fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBinormal3fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3fvEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBinormal3iEXT( void *args )
{
    struct glBinormal3iEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBinormal3iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3iEXT( params->bx, params->by, params->bz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBinormal3ivEXT( void *args )
{
    struct glBinormal3ivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBinormal3ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3ivEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBinormal3sEXT( void *args )
{
    struct glBinormal3sEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBinormal3sEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3sEXT( params->bx, params->by, params->bz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBinormal3svEXT( void *args )
{
    struct glBinormal3svEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBinormal3svEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3svEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBinormalPointerEXT( void *args )
{
    struct glBinormalPointerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBinormalPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormalPointerEXT( params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBitmapxOES( void *args )
{
    struct glBitmapxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBitmapxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBitmapxOES( params->width, params->height, params->xorig, params->yorig, params->xmove, params->ymove, params->bitmap );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendBarrier( void *args )
{
    struct glBlendBarrier_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendBarrier) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendBarrier();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendBarrierKHR( void *args )
{
    struct glBlendBarrierKHR_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendBarrierKHR) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendBarrierKHR();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendBarrierNV( void *args )
{
    struct glBlendBarrierNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendBarrierNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendBarrierNV();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendColor( void *args )
{
    struct glBlendColor_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendColor) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendColor( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendColorEXT( void *args )
{
    struct glBlendColorEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendColorEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendColorEXT( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendColorxOES( void *args )
{
    struct glBlendColorxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendColorxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendColorxOES( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendEquation( void *args )
{
    struct glBlendEquation_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendEquation) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquation( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendEquationEXT( void *args )
{
    struct glBlendEquationEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendEquationEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationEXT( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendEquationIndexedAMD( void *args )
{
    struct glBlendEquationIndexedAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendEquationIndexedAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationIndexedAMD( params->buf, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendEquationSeparate( void *args )
{
    struct glBlendEquationSeparate_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendEquationSeparate) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationSeparate( params->modeRGB, params->modeAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendEquationSeparateEXT( void *args )
{
    struct glBlendEquationSeparateEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendEquationSeparateEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationSeparateEXT( params->modeRGB, params->modeAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendEquationSeparateIndexedAMD( void *args )
{
    struct glBlendEquationSeparateIndexedAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendEquationSeparateIndexedAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationSeparateIndexedAMD( params->buf, params->modeRGB, params->modeAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendEquationSeparatei( void *args )
{
    struct glBlendEquationSeparatei_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendEquationSeparatei) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationSeparatei( params->buf, params->modeRGB, params->modeAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendEquationSeparateiARB( void *args )
{
    struct glBlendEquationSeparateiARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendEquationSeparateiARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationSeparateiARB( params->buf, params->modeRGB, params->modeAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendEquationi( void *args )
{
    struct glBlendEquationi_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendEquationi) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationi( params->buf, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendEquationiARB( void *args )
{
    struct glBlendEquationiARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendEquationiARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationiARB( params->buf, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendFuncIndexedAMD( void *args )
{
    struct glBlendFuncIndexedAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendFuncIndexedAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFuncIndexedAMD( params->buf, params->src, params->dst );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendFuncSeparate( void *args )
{
    struct glBlendFuncSeparate_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendFuncSeparate) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFuncSeparate( params->sfactorRGB, params->dfactorRGB, params->sfactorAlpha, params->dfactorAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendFuncSeparateEXT( void *args )
{
    struct glBlendFuncSeparateEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendFuncSeparateEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFuncSeparateEXT( params->sfactorRGB, params->dfactorRGB, params->sfactorAlpha, params->dfactorAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendFuncSeparateINGR( void *args )
{
    struct glBlendFuncSeparateINGR_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendFuncSeparateINGR) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFuncSeparateINGR( params->sfactorRGB, params->dfactorRGB, params->sfactorAlpha, params->dfactorAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendFuncSeparateIndexedAMD( void *args )
{
    struct glBlendFuncSeparateIndexedAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendFuncSeparateIndexedAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFuncSeparateIndexedAMD( params->buf, params->srcRGB, params->dstRGB, params->srcAlpha, params->dstAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendFuncSeparatei( void *args )
{
    struct glBlendFuncSeparatei_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendFuncSeparatei) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFuncSeparatei( params->buf, params->srcRGB, params->dstRGB, params->srcAlpha, params->dstAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendFuncSeparateiARB( void *args )
{
    struct glBlendFuncSeparateiARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendFuncSeparateiARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFuncSeparateiARB( params->buf, params->srcRGB, params->dstRGB, params->srcAlpha, params->dstAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendFunci( void *args )
{
    struct glBlendFunci_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendFunci) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFunci( params->buf, params->src, params->dst );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendFunciARB( void *args )
{
    struct glBlendFunciARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendFunciARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFunciARB( params->buf, params->src, params->dst );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlendParameteriNV( void *args )
{
    struct glBlendParameteriNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlendParameteriNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendParameteriNV( params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlitFramebuffer( void *args )
{
    struct glBlitFramebuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlitFramebuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlitFramebuffer( params->srcX0, params->srcY0, params->srcX1, params->srcY1, params->dstX0, params->dstY0, params->dstX1, params->dstY1, params->mask, params->filter );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlitFramebufferEXT( void *args )
{
    struct glBlitFramebufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlitFramebufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlitFramebufferEXT( params->srcX0, params->srcY0, params->srcX1, params->srcY1, params->dstX0, params->dstY0, params->dstX1, params->dstY1, params->mask, params->filter );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlitFramebufferLayerEXT( void *args )
{
    struct glBlitFramebufferLayerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlitFramebufferLayerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlitFramebufferLayerEXT( params->srcX0, params->srcY0, params->srcX1, params->srcY1, params->srcLayer, params->dstX0, params->dstY0, params->dstX1, params->dstY1, params->dstLayer, params->mask, params->filter );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlitFramebufferLayersEXT( void *args )
{
    struct glBlitFramebufferLayersEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlitFramebufferLayersEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlitFramebufferLayersEXT( params->srcX0, params->srcY0, params->srcX1, params->srcY1, params->dstX0, params->dstY0, params->dstX1, params->dstY1, params->mask, params->filter );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBlitNamedFramebuffer( void *args )
{
    struct glBlitNamedFramebuffer_params *params = args;
    GLuint readFramebuffer = params->readFramebuffer;
    GLuint drawFramebuffer = params->drawFramebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBlitNamedFramebuffer) return STATUS_NOT_IMPLEMENTED;
    if (!readFramebuffer) readFramebuffer = get_default_fbo( params->teb, GL_READ_FRAMEBUFFER );
    if (!drawFramebuffer) drawFramebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glBlitNamedFramebuffer( readFramebuffer, drawFramebuffer, params->srcX0, params->srcY0, params->srcX1, params->srcY1, params->dstX0, params->dstY0, params->dstX1, params->dstY1, params->mask, params->filter );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBufferAddressRangeNV( void *args )
{
    struct glBufferAddressRangeNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBufferAddressRangeNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferAddressRangeNV( params->pname, params->index, params->address, params->length );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBufferAttachMemoryNV( void *args )
{
    struct glBufferAttachMemoryNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBufferAttachMemoryNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferAttachMemoryNV( params->target, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBufferData( void *args )
{
    struct glBufferData_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBufferData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferData( params->target, params->size, params->data, params->usage );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBufferDataARB( void *args )
{
    struct glBufferDataARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBufferDataARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferDataARB( params->target, params->size, params->data, params->usage );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBufferPageCommitmentARB( void *args )
{
    struct glBufferPageCommitmentARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBufferPageCommitmentARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferPageCommitmentARB( params->target, params->offset, params->size, params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBufferPageCommitmentMemNV( void *args )
{
    struct glBufferPageCommitmentMemNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBufferPageCommitmentMemNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferPageCommitmentMemNV( params->target, params->offset, params->size, params->memory, params->memOffset, params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBufferParameteriAPPLE( void *args )
{
    struct glBufferParameteriAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBufferParameteriAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferParameteriAPPLE( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBufferRegionEnabled( void *args )
{
    struct glBufferRegionEnabled_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBufferRegionEnabled) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glBufferRegionEnabled();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBufferStorage( void *args )
{
    struct glBufferStorage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBufferStorage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferStorage( params->target, params->size, params->data, params->flags );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBufferStorageMemEXT( void *args )
{
    struct glBufferStorageMemEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBufferStorageMemEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferStorageMemEXT( params->target, params->size, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBufferSubData( void *args )
{
    struct glBufferSubData_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferSubData( params->target, params->offset, params->size, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glBufferSubDataARB( void *args )
{
    struct glBufferSubDataARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glBufferSubDataARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferSubDataARB( params->target, params->offset, params->size, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCallCommandListNV( void *args )
{
    struct glCallCommandListNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCallCommandListNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCallCommandListNV( params->list );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCheckFramebufferStatus( void *args )
{
    struct glCheckFramebufferStatus_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCheckFramebufferStatus) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCheckFramebufferStatus( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCheckFramebufferStatusEXT( void *args )
{
    struct glCheckFramebufferStatusEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCheckFramebufferStatusEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCheckFramebufferStatusEXT( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCheckNamedFramebufferStatus( void *args )
{
    struct glCheckNamedFramebufferStatus_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCheckNamedFramebufferStatus) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, params->target );
    params->ret = funcs->p_glCheckNamedFramebufferStatus( framebuffer, params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCheckNamedFramebufferStatusEXT( void *args )
{
    struct glCheckNamedFramebufferStatusEXT_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCheckNamedFramebufferStatusEXT) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, params->target );
    params->ret = funcs->p_glCheckNamedFramebufferStatusEXT( framebuffer, params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClampColor( void *args )
{
    struct glClampColor_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClampColor) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClampColor( params->target, params->clamp );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClampColorARB( void *args )
{
    struct glClampColorARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClampColorARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClampColorARB( params->target, params->clamp );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearAccumxOES( void *args )
{
    struct glClearAccumxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearAccumxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearAccumxOES( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearBufferData( void *args )
{
    struct glClearBufferData_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearBufferData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearBufferData( params->target, params->internalformat, params->format, params->type, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearBufferSubData( void *args )
{
    struct glClearBufferSubData_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearBufferSubData( params->target, params->internalformat, params->offset, params->size, params->format, params->type, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearBufferfi( void *args )
{
    struct glClearBufferfi_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearBufferfi) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearBufferfi( params->buffer, params->drawbuffer, params->depth, params->stencil );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearBufferfv( void *args )
{
    struct glClearBufferfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearBufferfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearBufferfv( params->buffer, params->drawbuffer, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearBufferiv( void *args )
{
    struct glClearBufferiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearBufferiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearBufferiv( params->buffer, params->drawbuffer, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearBufferuiv( void *args )
{
    struct glClearBufferuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearBufferuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearBufferuiv( params->buffer, params->drawbuffer, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearColorIiEXT( void *args )
{
    struct glClearColorIiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearColorIiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearColorIiEXT( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearColorIuiEXT( void *args )
{
    struct glClearColorIuiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearColorIuiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearColorIuiEXT( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearColorx( void *args )
{
    struct glClearColorx_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearColorx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearColorx( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearColorxOES( void *args )
{
    struct glClearColorxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearColorxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearColorxOES( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearDepthdNV( void *args )
{
    struct glClearDepthdNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearDepthdNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearDepthdNV( params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearDepthf( void *args )
{
    struct glClearDepthf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearDepthf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearDepthf( params->d );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearDepthfOES( void *args )
{
    struct glClearDepthfOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearDepthfOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearDepthfOES( params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearDepthx( void *args )
{
    struct glClearDepthx_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearDepthx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearDepthx( params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearDepthxOES( void *args )
{
    struct glClearDepthxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearDepthxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearDepthxOES( params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearNamedBufferData( void *args )
{
    struct glClearNamedBufferData_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearNamedBufferData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearNamedBufferData( params->buffer, params->internalformat, params->format, params->type, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearNamedBufferDataEXT( void *args )
{
    struct glClearNamedBufferDataEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearNamedBufferDataEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearNamedBufferDataEXT( params->buffer, params->internalformat, params->format, params->type, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearNamedBufferSubData( void *args )
{
    struct glClearNamedBufferSubData_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearNamedBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearNamedBufferSubData( params->buffer, params->internalformat, params->offset, params->size, params->format, params->type, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearNamedBufferSubDataEXT( void *args )
{
    struct glClearNamedBufferSubDataEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearNamedBufferSubDataEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearNamedBufferSubDataEXT( params->buffer, params->internalformat, params->offset, params->size, params->format, params->type, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearNamedFramebufferfi( void *args )
{
    struct glClearNamedFramebufferfi_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearNamedFramebufferfi) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glClearNamedFramebufferfi( framebuffer, params->buffer, params->drawbuffer, params->depth, params->stencil );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearNamedFramebufferfv( void *args )
{
    struct glClearNamedFramebufferfv_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearNamedFramebufferfv) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glClearNamedFramebufferfv( framebuffer, params->buffer, params->drawbuffer, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearNamedFramebufferiv( void *args )
{
    struct glClearNamedFramebufferiv_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearNamedFramebufferiv) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glClearNamedFramebufferiv( framebuffer, params->buffer, params->drawbuffer, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearNamedFramebufferuiv( void *args )
{
    struct glClearNamedFramebufferuiv_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearNamedFramebufferuiv) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glClearNamedFramebufferuiv( framebuffer, params->buffer, params->drawbuffer, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearTexImage( void *args )
{
    struct glClearTexImage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearTexImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearTexImage( params->texture, params->level, params->format, params->type, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClearTexSubImage( void *args )
{
    struct glClearTexSubImage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClearTexSubImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearTexSubImage( params->texture, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->type, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClientActiveTexture( void *args )
{
    struct glClientActiveTexture_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClientActiveTexture) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClientActiveTexture( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClientActiveTextureARB( void *args )
{
    struct glClientActiveTextureARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClientActiveTextureARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClientActiveTextureARB( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClientActiveVertexStreamATI( void *args )
{
    struct glClientActiveVertexStreamATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClientActiveVertexStreamATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClientActiveVertexStreamATI( params->stream );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClientAttribDefaultEXT( void *args )
{
    struct glClientAttribDefaultEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClientAttribDefaultEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClientAttribDefaultEXT( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClientWaitSemaphoreui64NVX( void *args )
{
    struct glClientWaitSemaphoreui64NVX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClientWaitSemaphoreui64NVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClientWaitSemaphoreui64NVX( params->fenceObjectCount, params->semaphoreArray, params->fenceValueArray );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClientWaitSync( void *args )
{
    struct glClientWaitSync_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClientWaitSync) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glClientWaitSync( get_unix_sync( params->sync ), params->flags, params->timeout );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClipControl( void *args )
{
    struct glClipControl_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClipControl) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClipControl( params->origin, params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClipPlanef( void *args )
{
    struct glClipPlanef_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClipPlanef) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClipPlanef( params->p, params->eqn );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClipPlanefOES( void *args )
{
    struct glClipPlanefOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClipPlanefOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClipPlanefOES( params->plane, params->equation );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClipPlanex( void *args )
{
    struct glClipPlanex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClipPlanex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClipPlanex( params->plane, params->equation );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glClipPlanexOES( void *args )
{
    struct glClipPlanexOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glClipPlanexOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClipPlanexOES( params->plane, params->equation );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor3fVertex3fSUN( void *args )
{
    struct glColor3fVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3fVertex3fSUN( params->r, params->g, params->b, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor3fVertex3fvSUN( void *args )
{
    struct glColor3fVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3fVertex3fvSUN( params->c, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor3hNV( void *args )
{
    struct glColor3hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3hNV( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor3hvNV( void *args )
{
    struct glColor3hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3hvNV( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor3xOES( void *args )
{
    struct glColor3xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3xOES( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor3xvOES( void *args )
{
    struct glColor3xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor3xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3xvOES( params->components );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor4fNormal3fVertex3fSUN( void *args )
{
    struct glColor4fNormal3fVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4fNormal3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4fNormal3fVertex3fSUN( params->r, params->g, params->b, params->a, params->nx, params->ny, params->nz, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor4fNormal3fVertex3fvSUN( void *args )
{
    struct glColor4fNormal3fVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4fNormal3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4fNormal3fVertex3fvSUN( params->c, params->n, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor4hNV( void *args )
{
    struct glColor4hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4hNV( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor4hvNV( void *args )
{
    struct glColor4hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4hvNV( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor4ubVertex2fSUN( void *args )
{
    struct glColor4ubVertex2fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4ubVertex2fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4ubVertex2fSUN( params->r, params->g, params->b, params->a, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor4ubVertex2fvSUN( void *args )
{
    struct glColor4ubVertex2fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4ubVertex2fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4ubVertex2fvSUN( params->c, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor4ubVertex3fSUN( void *args )
{
    struct glColor4ubVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4ubVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4ubVertex3fSUN( params->r, params->g, params->b, params->a, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor4ubVertex3fvSUN( void *args )
{
    struct glColor4ubVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4ubVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4ubVertex3fvSUN( params->c, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor4x( void *args )
{
    struct glColor4x_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4x) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4x( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor4xOES( void *args )
{
    struct glColor4xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4xOES( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColor4xvOES( void *args )
{
    struct glColor4xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColor4xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4xvOES( params->components );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorFormatNV( void *args )
{
    struct glColorFormatNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorFormatNV( params->size, params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorFragmentOp1ATI( void *args )
{
    struct glColorFragmentOp1ATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorFragmentOp1ATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorFragmentOp1ATI( params->op, params->dst, params->dstMask, params->dstMod, params->arg1, params->arg1Rep, params->arg1Mod );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorFragmentOp2ATI( void *args )
{
    struct glColorFragmentOp2ATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorFragmentOp2ATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorFragmentOp2ATI( params->op, params->dst, params->dstMask, params->dstMod, params->arg1, params->arg1Rep, params->arg1Mod, params->arg2, params->arg2Rep, params->arg2Mod );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorFragmentOp3ATI( void *args )
{
    struct glColorFragmentOp3ATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorFragmentOp3ATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorFragmentOp3ATI( params->op, params->dst, params->dstMask, params->dstMod, params->arg1, params->arg1Rep, params->arg1Mod, params->arg2, params->arg2Rep, params->arg2Mod, params->arg3, params->arg3Rep, params->arg3Mod );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorMaskIndexedEXT( void *args )
{
    struct glColorMaskIndexedEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorMaskIndexedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorMaskIndexedEXT( params->index, params->r, params->g, params->b, params->a );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorMaski( void *args )
{
    struct glColorMaski_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorMaski) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorMaski( params->index, params->r, params->g, params->b, params->a );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorP3ui( void *args )
{
    struct glColorP3ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorP3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorP3ui( params->type, params->color );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorP3uiv( void *args )
{
    struct glColorP3uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorP3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorP3uiv( params->type, params->color );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorP4ui( void *args )
{
    struct glColorP4ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorP4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorP4ui( params->type, params->color );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorP4uiv( void *args )
{
    struct glColorP4uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorP4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorP4uiv( params->type, params->color );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorPointerEXT( void *args )
{
    struct glColorPointerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorPointerEXT( params->size, params->type, params->stride, params->count, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorPointerListIBM( void *args )
{
    struct glColorPointerListIBM_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorPointerListIBM) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorPointerListIBM( params->size, params->type, params->stride, params->pointer, params->ptrstride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorPointervINTEL( void *args )
{
    struct glColorPointervINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorPointervINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorPointervINTEL( params->size, params->type, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorSubTable( void *args )
{
    struct glColorSubTable_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorSubTable) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorSubTable( params->target, params->start, params->count, params->format, params->type, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorSubTableEXT( void *args )
{
    struct glColorSubTableEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorSubTableEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorSubTableEXT( params->target, params->start, params->count, params->format, params->type, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorTable( void *args )
{
    struct glColorTable_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorTable) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorTable( params->target, params->internalformat, params->width, params->format, params->type, params->table );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorTableEXT( void *args )
{
    struct glColorTableEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorTableEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorTableEXT( params->target, params->internalFormat, params->width, params->format, params->type, params->table );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorTableParameterfv( void *args )
{
    struct glColorTableParameterfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorTableParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorTableParameterfv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorTableParameterfvSGI( void *args )
{
    struct glColorTableParameterfvSGI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorTableParameterfvSGI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorTableParameterfvSGI( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorTableParameteriv( void *args )
{
    struct glColorTableParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorTableParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorTableParameteriv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorTableParameterivSGI( void *args )
{
    struct glColorTableParameterivSGI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorTableParameterivSGI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorTableParameterivSGI( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glColorTableSGI( void *args )
{
    struct glColorTableSGI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glColorTableSGI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorTableSGI( params->target, params->internalformat, params->width, params->format, params->type, params->table );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCombinerInputNV( void *args )
{
    struct glCombinerInputNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCombinerInputNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCombinerInputNV( params->stage, params->portion, params->variable, params->input, params->mapping, params->componentUsage );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCombinerOutputNV( void *args )
{
    struct glCombinerOutputNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCombinerOutputNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCombinerOutputNV( params->stage, params->portion, params->abOutput, params->cdOutput, params->sumOutput, params->scale, params->bias, params->abDotProduct, params->cdDotProduct, params->muxSum );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCombinerParameterfNV( void *args )
{
    struct glCombinerParameterfNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCombinerParameterfNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCombinerParameterfNV( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCombinerParameterfvNV( void *args )
{
    struct glCombinerParameterfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCombinerParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCombinerParameterfvNV( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCombinerParameteriNV( void *args )
{
    struct glCombinerParameteriNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCombinerParameteriNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCombinerParameteriNV( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCombinerParameterivNV( void *args )
{
    struct glCombinerParameterivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCombinerParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCombinerParameterivNV( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCombinerStageParameterfvNV( void *args )
{
    struct glCombinerStageParameterfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCombinerStageParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCombinerStageParameterfvNV( params->stage, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCommandListSegmentsNV( void *args )
{
    struct glCommandListSegmentsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCommandListSegmentsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCommandListSegmentsNV( params->list, params->segments );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompileCommandListNV( void *args )
{
    struct glCompileCommandListNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompileCommandListNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompileCommandListNV( params->list );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompileShader( void *args )
{
    struct glCompileShader_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompileShader) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompileShader( params->shader );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompileShaderARB( void *args )
{
    struct glCompileShaderARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompileShaderARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompileShaderARB( params->shaderObj );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompileShaderIncludeARB( void *args )
{
    struct glCompileShaderIncludeARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompileShaderIncludeARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompileShaderIncludeARB( params->shader, params->count, params->path, params->length );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedMultiTexImage1DEXT( void *args )
{
    struct glCompressedMultiTexImage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedMultiTexImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedMultiTexImage1DEXT( params->texunit, params->target, params->level, params->internalformat, params->width, params->border, params->imageSize, params->bits );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedMultiTexImage2DEXT( void *args )
{
    struct glCompressedMultiTexImage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedMultiTexImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedMultiTexImage2DEXT( params->texunit, params->target, params->level, params->internalformat, params->width, params->height, params->border, params->imageSize, params->bits );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedMultiTexImage3DEXT( void *args )
{
    struct glCompressedMultiTexImage3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedMultiTexImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedMultiTexImage3DEXT( params->texunit, params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->border, params->imageSize, params->bits );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedMultiTexSubImage1DEXT( void *args )
{
    struct glCompressedMultiTexSubImage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedMultiTexSubImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedMultiTexSubImage1DEXT( params->texunit, params->target, params->level, params->xoffset, params->width, params->format, params->imageSize, params->bits );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedMultiTexSubImage2DEXT( void *args )
{
    struct glCompressedMultiTexSubImage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedMultiTexSubImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedMultiTexSubImage2DEXT( params->texunit, params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->imageSize, params->bits );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedMultiTexSubImage3DEXT( void *args )
{
    struct glCompressedMultiTexSubImage3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedMultiTexSubImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedMultiTexSubImage3DEXT( params->texunit, params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->imageSize, params->bits );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTexImage1D( void *args )
{
    struct glCompressedTexImage1D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTexImage1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexImage1D( params->target, params->level, params->internalformat, params->width, params->border, params->imageSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTexImage1DARB( void *args )
{
    struct glCompressedTexImage1DARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTexImage1DARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexImage1DARB( params->target, params->level, params->internalformat, params->width, params->border, params->imageSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTexImage2D( void *args )
{
    struct glCompressedTexImage2D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTexImage2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexImage2D( params->target, params->level, params->internalformat, params->width, params->height, params->border, params->imageSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTexImage2DARB( void *args )
{
    struct glCompressedTexImage2DARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTexImage2DARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexImage2DARB( params->target, params->level, params->internalformat, params->width, params->height, params->border, params->imageSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTexImage3D( void *args )
{
    struct glCompressedTexImage3D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTexImage3D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexImage3D( params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->border, params->imageSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTexImage3DARB( void *args )
{
    struct glCompressedTexImage3DARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTexImage3DARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexImage3DARB( params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->border, params->imageSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTexSubImage1D( void *args )
{
    struct glCompressedTexSubImage1D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTexSubImage1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexSubImage1D( params->target, params->level, params->xoffset, params->width, params->format, params->imageSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTexSubImage1DARB( void *args )
{
    struct glCompressedTexSubImage1DARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTexSubImage1DARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexSubImage1DARB( params->target, params->level, params->xoffset, params->width, params->format, params->imageSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTexSubImage2D( void *args )
{
    struct glCompressedTexSubImage2D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTexSubImage2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexSubImage2D( params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->imageSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTexSubImage2DARB( void *args )
{
    struct glCompressedTexSubImage2DARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTexSubImage2DARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexSubImage2DARB( params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->imageSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTexSubImage3D( void *args )
{
    struct glCompressedTexSubImage3D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTexSubImage3D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexSubImage3D( params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->imageSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTexSubImage3DARB( void *args )
{
    struct glCompressedTexSubImage3DARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTexSubImage3DARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexSubImage3DARB( params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->imageSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTextureImage1DEXT( void *args )
{
    struct glCompressedTextureImage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTextureImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureImage1DEXT( params->texture, params->target, params->level, params->internalformat, params->width, params->border, params->imageSize, params->bits );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTextureImage2DEXT( void *args )
{
    struct glCompressedTextureImage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTextureImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureImage2DEXT( params->texture, params->target, params->level, params->internalformat, params->width, params->height, params->border, params->imageSize, params->bits );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTextureImage3DEXT( void *args )
{
    struct glCompressedTextureImage3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTextureImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureImage3DEXT( params->texture, params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->border, params->imageSize, params->bits );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTextureSubImage1D( void *args )
{
    struct glCompressedTextureSubImage1D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTextureSubImage1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureSubImage1D( params->texture, params->level, params->xoffset, params->width, params->format, params->imageSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTextureSubImage1DEXT( void *args )
{
    struct glCompressedTextureSubImage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTextureSubImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureSubImage1DEXT( params->texture, params->target, params->level, params->xoffset, params->width, params->format, params->imageSize, params->bits );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTextureSubImage2D( void *args )
{
    struct glCompressedTextureSubImage2D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTextureSubImage2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureSubImage2D( params->texture, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->imageSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTextureSubImage2DEXT( void *args )
{
    struct glCompressedTextureSubImage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTextureSubImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureSubImage2DEXT( params->texture, params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->imageSize, params->bits );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTextureSubImage3D( void *args )
{
    struct glCompressedTextureSubImage3D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTextureSubImage3D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureSubImage3D( params->texture, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->imageSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCompressedTextureSubImage3DEXT( void *args )
{
    struct glCompressedTextureSubImage3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCompressedTextureSubImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureSubImage3DEXT( params->texture, params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->imageSize, params->bits );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glConservativeRasterParameterfNV( void *args )
{
    struct glConservativeRasterParameterfNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glConservativeRasterParameterfNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConservativeRasterParameterfNV( params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glConservativeRasterParameteriNV( void *args )
{
    struct glConservativeRasterParameteriNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glConservativeRasterParameteriNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConservativeRasterParameteriNV( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glConvolutionFilter1D( void *args )
{
    struct glConvolutionFilter1D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glConvolutionFilter1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionFilter1D( params->target, params->internalformat, params->width, params->format, params->type, params->image );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glConvolutionFilter1DEXT( void *args )
{
    struct glConvolutionFilter1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glConvolutionFilter1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionFilter1DEXT( params->target, params->internalformat, params->width, params->format, params->type, params->image );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glConvolutionFilter2D( void *args )
{
    struct glConvolutionFilter2D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glConvolutionFilter2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionFilter2D( params->target, params->internalformat, params->width, params->height, params->format, params->type, params->image );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glConvolutionFilter2DEXT( void *args )
{
    struct glConvolutionFilter2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glConvolutionFilter2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionFilter2DEXT( params->target, params->internalformat, params->width, params->height, params->format, params->type, params->image );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glConvolutionParameterf( void *args )
{
    struct glConvolutionParameterf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glConvolutionParameterf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameterf( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glConvolutionParameterfEXT( void *args )
{
    struct glConvolutionParameterfEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glConvolutionParameterfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameterfEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glConvolutionParameterfv( void *args )
{
    struct glConvolutionParameterfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glConvolutionParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameterfv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glConvolutionParameterfvEXT( void *args )
{
    struct glConvolutionParameterfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glConvolutionParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameterfvEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glConvolutionParameteri( void *args )
{
    struct glConvolutionParameteri_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glConvolutionParameteri) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameteri( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glConvolutionParameteriEXT( void *args )
{
    struct glConvolutionParameteriEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glConvolutionParameteriEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameteriEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glConvolutionParameteriv( void *args )
{
    struct glConvolutionParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glConvolutionParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameteriv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glConvolutionParameterivEXT( void *args )
{
    struct glConvolutionParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glConvolutionParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameterivEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glConvolutionParameterxOES( void *args )
{
    struct glConvolutionParameterxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glConvolutionParameterxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameterxOES( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glConvolutionParameterxvOES( void *args )
{
    struct glConvolutionParameterxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glConvolutionParameterxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameterxvOES( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyBufferSubData( void *args )
{
    struct glCopyBufferSubData_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyBufferSubData( params->readTarget, params->writeTarget, params->readOffset, params->writeOffset, params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyColorSubTable( void *args )
{
    struct glCopyColorSubTable_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyColorSubTable) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyColorSubTable( params->target, params->start, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyColorSubTableEXT( void *args )
{
    struct glCopyColorSubTableEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyColorSubTableEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyColorSubTableEXT( params->target, params->start, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyColorTable( void *args )
{
    struct glCopyColorTable_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyColorTable) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyColorTable( params->target, params->internalformat, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyColorTableSGI( void *args )
{
    struct glCopyColorTableSGI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyColorTableSGI) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyColorTableSGI( params->target, params->internalformat, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyConvolutionFilter1D( void *args )
{
    struct glCopyConvolutionFilter1D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyConvolutionFilter1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyConvolutionFilter1D( params->target, params->internalformat, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyConvolutionFilter1DEXT( void *args )
{
    struct glCopyConvolutionFilter1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyConvolutionFilter1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyConvolutionFilter1DEXT( params->target, params->internalformat, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyConvolutionFilter2D( void *args )
{
    struct glCopyConvolutionFilter2D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyConvolutionFilter2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyConvolutionFilter2D( params->target, params->internalformat, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyConvolutionFilter2DEXT( void *args )
{
    struct glCopyConvolutionFilter2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyConvolutionFilter2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyConvolutionFilter2DEXT( params->target, params->internalformat, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyImageSubData( void *args )
{
    struct glCopyImageSubData_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyImageSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyImageSubData( params->srcName, params->srcTarget, params->srcLevel, params->srcX, params->srcY, params->srcZ, params->dstName, params->dstTarget, params->dstLevel, params->dstX, params->dstY, params->dstZ, params->srcWidth, params->srcHeight, params->srcDepth );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyImageSubDataNV( void *args )
{
    struct glCopyImageSubDataNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyImageSubDataNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyImageSubDataNV( params->srcName, params->srcTarget, params->srcLevel, params->srcX, params->srcY, params->srcZ, params->dstName, params->dstTarget, params->dstLevel, params->dstX, params->dstY, params->dstZ, params->width, params->height, params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyMultiTexImage1DEXT( void *args )
{
    struct glCopyMultiTexImage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyMultiTexImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyMultiTexImage1DEXT( params->texunit, params->target, params->level, params->internalformat, params->x, params->y, params->width, params->border );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyMultiTexImage2DEXT( void *args )
{
    struct glCopyMultiTexImage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyMultiTexImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyMultiTexImage2DEXT( params->texunit, params->target, params->level, params->internalformat, params->x, params->y, params->width, params->height, params->border );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyMultiTexSubImage1DEXT( void *args )
{
    struct glCopyMultiTexSubImage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyMultiTexSubImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyMultiTexSubImage1DEXT( params->texunit, params->target, params->level, params->xoffset, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyMultiTexSubImage2DEXT( void *args )
{
    struct glCopyMultiTexSubImage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyMultiTexSubImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyMultiTexSubImage2DEXT( params->texunit, params->target, params->level, params->xoffset, params->yoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyMultiTexSubImage3DEXT( void *args )
{
    struct glCopyMultiTexSubImage3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyMultiTexSubImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyMultiTexSubImage3DEXT( params->texunit, params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyNamedBufferSubData( void *args )
{
    struct glCopyNamedBufferSubData_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyNamedBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyNamedBufferSubData( params->readBuffer, params->writeBuffer, params->readOffset, params->writeOffset, params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyPathNV( void *args )
{
    struct glCopyPathNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyPathNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyPathNV( params->resultPath, params->srcPath );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyTexImage1DEXT( void *args )
{
    struct glCopyTexImage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTexImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyTexImage1DEXT( params->target, params->level, params->internalformat, params->x, params->y, params->width, params->border );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyTexImage2DEXT( void *args )
{
    struct glCopyTexImage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTexImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyTexImage2DEXT( params->target, params->level, params->internalformat, params->x, params->y, params->width, params->height, params->border );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyTexSubImage1DEXT( void *args )
{
    struct glCopyTexSubImage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTexSubImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyTexSubImage1DEXT( params->target, params->level, params->xoffset, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyTexSubImage2DEXT( void *args )
{
    struct glCopyTexSubImage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTexSubImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyTexSubImage2DEXT( params->target, params->level, params->xoffset, params->yoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyTexSubImage3D( void *args )
{
    struct glCopyTexSubImage3D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTexSubImage3D) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyTexSubImage3D( params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyTexSubImage3DEXT( void *args )
{
    struct glCopyTexSubImage3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTexSubImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyTexSubImage3DEXT( params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyTextureImage1DEXT( void *args )
{
    struct glCopyTextureImage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTextureImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyTextureImage1DEXT( params->texture, params->target, params->level, params->internalformat, params->x, params->y, params->width, params->border );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyTextureImage2DEXT( void *args )
{
    struct glCopyTextureImage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTextureImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyTextureImage2DEXT( params->texture, params->target, params->level, params->internalformat, params->x, params->y, params->width, params->height, params->border );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyTextureSubImage1D( void *args )
{
    struct glCopyTextureSubImage1D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTextureSubImage1D) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyTextureSubImage1D( params->texture, params->level, params->xoffset, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyTextureSubImage1DEXT( void *args )
{
    struct glCopyTextureSubImage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTextureSubImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyTextureSubImage1DEXT( params->texture, params->target, params->level, params->xoffset, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyTextureSubImage2D( void *args )
{
    struct glCopyTextureSubImage2D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTextureSubImage2D) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyTextureSubImage2D( params->texture, params->level, params->xoffset, params->yoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyTextureSubImage2DEXT( void *args )
{
    struct glCopyTextureSubImage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTextureSubImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyTextureSubImage2DEXT( params->texture, params->target, params->level, params->xoffset, params->yoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyTextureSubImage3D( void *args )
{
    struct glCopyTextureSubImage3D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTextureSubImage3D) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyTextureSubImage3D( params->texture, params->level, params->xoffset, params->yoffset, params->zoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCopyTextureSubImage3DEXT( void *args )
{
    struct glCopyTextureSubImage3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCopyTextureSubImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( params->teb, TRUE );
    funcs->p_glCopyTextureSubImage3DEXT( params->texture, params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCoverFillPathInstancedNV( void *args )
{
    struct glCoverFillPathInstancedNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCoverFillPathInstancedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCoverFillPathInstancedNV( params->numPaths, params->pathNameType, params->paths, params->pathBase, params->coverMode, params->transformType, params->transformValues );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCoverFillPathNV( void *args )
{
    struct glCoverFillPathNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCoverFillPathNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCoverFillPathNV( params->path, params->coverMode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCoverStrokePathInstancedNV( void *args )
{
    struct glCoverStrokePathInstancedNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCoverStrokePathInstancedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCoverStrokePathInstancedNV( params->numPaths, params->pathNameType, params->paths, params->pathBase, params->coverMode, params->transformType, params->transformValues );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCoverStrokePathNV( void *args )
{
    struct glCoverStrokePathNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCoverStrokePathNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCoverStrokePathNV( params->path, params->coverMode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCoverageModulationNV( void *args )
{
    struct glCoverageModulationNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCoverageModulationNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCoverageModulationNV( params->components );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCoverageModulationTableNV( void *args )
{
    struct glCoverageModulationTableNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCoverageModulationTableNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCoverageModulationTableNV( params->n, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateBuffers( void *args )
{
    struct glCreateBuffers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateBuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateBuffers( params->n, params->buffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateCommandListsNV( void *args )
{
    struct glCreateCommandListsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateCommandListsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateCommandListsNV( params->n, params->lists );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateFramebuffers( void *args )
{
    struct glCreateFramebuffers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateFramebuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateFramebuffers( params->n, params->framebuffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateMemoryObjectsEXT( void *args )
{
    struct glCreateMemoryObjectsEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateMemoryObjectsEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateMemoryObjectsEXT( params->n, params->memoryObjects );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreatePerfQueryINTEL( void *args )
{
    struct glCreatePerfQueryINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreatePerfQueryINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreatePerfQueryINTEL( params->queryId, params->queryHandle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateProgram( void *args )
{
    struct glCreateProgram_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateProgram) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCreateProgram();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateProgramObjectARB( void *args )
{
    struct glCreateProgramObjectARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateProgramObjectARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCreateProgramObjectARB();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateProgramPipelines( void *args )
{
    struct glCreateProgramPipelines_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateProgramPipelines) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateProgramPipelines( params->n, params->pipelines );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateProgressFenceNVX( void *args )
{
    struct glCreateProgressFenceNVX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateProgressFenceNVX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCreateProgressFenceNVX();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateQueries( void *args )
{
    struct glCreateQueries_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateQueries) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateQueries( params->target, params->n, params->ids );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateRenderbuffers( void *args )
{
    struct glCreateRenderbuffers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateRenderbuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateRenderbuffers( params->n, params->renderbuffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateSamplers( void *args )
{
    struct glCreateSamplers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateSamplers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateSamplers( params->n, params->samplers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateSemaphoresNV( void *args )
{
    struct glCreateSemaphoresNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateSemaphoresNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateSemaphoresNV( params->n, params->semaphores );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateShader( void *args )
{
    struct glCreateShader_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateShader) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCreateShader( params->type );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateShaderObjectARB( void *args )
{
    struct glCreateShaderObjectARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateShaderObjectARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCreateShaderObjectARB( params->shaderType );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateShaderProgramEXT( void *args )
{
    struct glCreateShaderProgramEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateShaderProgramEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCreateShaderProgramEXT( params->type, params->string );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateShaderProgramv( void *args )
{
    struct glCreateShaderProgramv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateShaderProgramv) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCreateShaderProgramv( params->type, params->count, params->strings );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateStatesNV( void *args )
{
    struct glCreateStatesNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateStatesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateStatesNV( params->n, params->states );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateSyncFromCLeventARB( void *args )
{
    struct glCreateSyncFromCLeventARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateSyncFromCLeventARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = wrap_glCreateSyncFromCLeventARB( params->teb, params->context, params->event, params->flags, params->ret, funcs->p_glCreateSyncFromCLeventARB );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateTextures( void *args )
{
    struct glCreateTextures_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateTextures) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateTextures( params->target, params->n, params->textures );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateTransformFeedbacks( void *args )
{
    struct glCreateTransformFeedbacks_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateTransformFeedbacks) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateTransformFeedbacks( params->n, params->ids );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCreateVertexArrays( void *args )
{
    struct glCreateVertexArrays_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCreateVertexArrays) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateVertexArrays( params->n, params->arrays );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCullParameterdvEXT( void *args )
{
    struct glCullParameterdvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCullParameterdvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCullParameterdvEXT( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCullParameterfvEXT( void *args )
{
    struct glCullParameterfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCullParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCullParameterfvEXT( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glCurrentPaletteMatrixARB( void *args )
{
    struct glCurrentPaletteMatrixARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glCurrentPaletteMatrixARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCurrentPaletteMatrixARB( params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDebugMessageCallback( void *args )
{
    struct glDebugMessageCallback_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDebugMessageCallback) return STATUS_NOT_IMPLEMENTED;
    wrap_glDebugMessageCallback( params->teb, params->callback, params->userParam, funcs->p_glDebugMessageCallback );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDebugMessageCallbackAMD( void *args )
{
    struct glDebugMessageCallbackAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDebugMessageCallbackAMD) return STATUS_NOT_IMPLEMENTED;
    wrap_glDebugMessageCallbackAMD( params->teb, params->callback, params->userParam, funcs->p_glDebugMessageCallbackAMD );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDebugMessageCallbackARB( void *args )
{
    struct glDebugMessageCallbackARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDebugMessageCallbackARB) return STATUS_NOT_IMPLEMENTED;
    wrap_glDebugMessageCallback( params->teb, params->callback, params->userParam, funcs->p_glDebugMessageCallbackARB );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDebugMessageControl( void *args )
{
    struct glDebugMessageControl_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDebugMessageControl) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDebugMessageControl( params->source, params->type, params->severity, params->count, params->ids, params->enabled );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDebugMessageControlARB( void *args )
{
    struct glDebugMessageControlARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDebugMessageControlARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDebugMessageControlARB( params->source, params->type, params->severity, params->count, params->ids, params->enabled );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDebugMessageEnableAMD( void *args )
{
    struct glDebugMessageEnableAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDebugMessageEnableAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDebugMessageEnableAMD( params->category, params->severity, params->count, params->ids, params->enabled );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDebugMessageInsert( void *args )
{
    struct glDebugMessageInsert_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDebugMessageInsert) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDebugMessageInsert( params->source, params->type, params->id, params->severity, params->length, params->buf );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDebugMessageInsertAMD( void *args )
{
    struct glDebugMessageInsertAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDebugMessageInsertAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDebugMessageInsertAMD( params->category, params->severity, params->id, params->length, params->buf );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDebugMessageInsertARB( void *args )
{
    struct glDebugMessageInsertARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDebugMessageInsertARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDebugMessageInsertARB( params->source, params->type, params->id, params->severity, params->length, params->buf );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeformSGIX( void *args )
{
    struct glDeformSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeformSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeformSGIX( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeformationMap3dSGIX( void *args )
{
    struct glDeformationMap3dSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeformationMap3dSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeformationMap3dSGIX( params->target, params->u1, params->u2, params->ustride, params->uorder, params->v1, params->v2, params->vstride, params->vorder, params->w1, params->w2, params->wstride, params->worder, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeformationMap3fSGIX( void *args )
{
    struct glDeformationMap3fSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeformationMap3fSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeformationMap3fSGIX( params->target, params->u1, params->u2, params->ustride, params->uorder, params->v1, params->v2, params->vstride, params->vorder, params->w1, params->w2, params->wstride, params->worder, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteAsyncMarkersSGIX( void *args )
{
    struct glDeleteAsyncMarkersSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteAsyncMarkersSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteAsyncMarkersSGIX( params->marker, params->range );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteBufferRegion( void *args )
{
    struct glDeleteBufferRegion_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteBufferRegion) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteBufferRegion( params->region );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteBuffers( void *args )
{
    struct glDeleteBuffers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteBuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteBuffers( params->n, params->buffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteBuffersARB( void *args )
{
    struct glDeleteBuffersARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteBuffersARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteBuffersARB( params->n, params->buffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteCommandListsNV( void *args )
{
    struct glDeleteCommandListsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteCommandListsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteCommandListsNV( params->n, params->lists );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteFencesAPPLE( void *args )
{
    struct glDeleteFencesAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteFencesAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteFencesAPPLE( params->n, params->fences );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteFencesNV( void *args )
{
    struct glDeleteFencesNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteFencesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteFencesNV( params->n, params->fences );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteFragmentShaderATI( void *args )
{
    struct glDeleteFragmentShaderATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteFragmentShaderATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteFragmentShaderATI( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteFramebuffers( void *args )
{
    struct glDeleteFramebuffers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteFramebuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteFramebuffers( params->n, params->framebuffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteFramebuffersEXT( void *args )
{
    struct glDeleteFramebuffersEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteFramebuffersEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteFramebuffersEXT( params->n, params->framebuffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteMemoryObjectsEXT( void *args )
{
    struct glDeleteMemoryObjectsEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteMemoryObjectsEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteMemoryObjectsEXT( params->n, params->memoryObjects );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteNamedStringARB( void *args )
{
    struct glDeleteNamedStringARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteNamedStringARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteNamedStringARB( params->namelen, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteNamesAMD( void *args )
{
    struct glDeleteNamesAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteNamesAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteNamesAMD( params->identifier, params->num, params->names );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteObjectARB( void *args )
{
    struct glDeleteObjectARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteObjectARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteObjectARB( params->obj );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteObjectBufferATI( void *args )
{
    struct glDeleteObjectBufferATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteObjectBufferATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteObjectBufferATI( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteOcclusionQueriesNV( void *args )
{
    struct glDeleteOcclusionQueriesNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteOcclusionQueriesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteOcclusionQueriesNV( params->n, params->ids );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeletePathsNV( void *args )
{
    struct glDeletePathsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeletePathsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeletePathsNV( params->path, params->range );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeletePerfMonitorsAMD( void *args )
{
    struct glDeletePerfMonitorsAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeletePerfMonitorsAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeletePerfMonitorsAMD( params->n, params->monitors );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeletePerfQueryINTEL( void *args )
{
    struct glDeletePerfQueryINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeletePerfQueryINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeletePerfQueryINTEL( params->queryHandle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteProgram( void *args )
{
    struct glDeleteProgram_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteProgram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteProgram( params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteProgramPipelines( void *args )
{
    struct glDeleteProgramPipelines_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteProgramPipelines) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteProgramPipelines( params->n, params->pipelines );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteProgramsARB( void *args )
{
    struct glDeleteProgramsARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteProgramsARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteProgramsARB( params->n, params->programs );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteProgramsNV( void *args )
{
    struct glDeleteProgramsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteProgramsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteProgramsNV( params->n, params->programs );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteQueries( void *args )
{
    struct glDeleteQueries_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteQueries) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteQueries( params->n, params->ids );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteQueriesARB( void *args )
{
    struct glDeleteQueriesARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteQueriesARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteQueriesARB( params->n, params->ids );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteQueryResourceTagNV( void *args )
{
    struct glDeleteQueryResourceTagNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteQueryResourceTagNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteQueryResourceTagNV( params->n, params->tagIds );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteRenderbuffers( void *args )
{
    struct glDeleteRenderbuffers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteRenderbuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteRenderbuffers( params->n, params->renderbuffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteRenderbuffersEXT( void *args )
{
    struct glDeleteRenderbuffersEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteRenderbuffersEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteRenderbuffersEXT( params->n, params->renderbuffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteSamplers( void *args )
{
    struct glDeleteSamplers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteSamplers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteSamplers( params->count, params->samplers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteSemaphoresEXT( void *args )
{
    struct glDeleteSemaphoresEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteSemaphoresEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteSemaphoresEXT( params->n, params->semaphores );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteShader( void *args )
{
    struct glDeleteShader_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteShader) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteShader( params->shader );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteStatesNV( void *args )
{
    struct glDeleteStatesNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteStatesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteStatesNV( params->n, params->states );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteSync( void *args )
{
    struct glDeleteSync_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteSync) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteSync( get_unix_sync( params->sync ) );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteTexturesEXT( void *args )
{
    struct glDeleteTexturesEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteTexturesEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteTexturesEXT( params->n, params->textures );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteTransformFeedbacks( void *args )
{
    struct glDeleteTransformFeedbacks_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteTransformFeedbacks) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteTransformFeedbacks( params->n, params->ids );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteTransformFeedbacksNV( void *args )
{
    struct glDeleteTransformFeedbacksNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteTransformFeedbacksNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteTransformFeedbacksNV( params->n, params->ids );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteVertexArrays( void *args )
{
    struct glDeleteVertexArrays_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteVertexArrays) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteVertexArrays( params->n, params->arrays );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteVertexArraysAPPLE( void *args )
{
    struct glDeleteVertexArraysAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteVertexArraysAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteVertexArraysAPPLE( params->n, params->arrays );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDeleteVertexShaderEXT( void *args )
{
    struct glDeleteVertexShaderEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDeleteVertexShaderEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteVertexShaderEXT( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDepthBoundsEXT( void *args )
{
    struct glDepthBoundsEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDepthBoundsEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthBoundsEXT( params->zmin, params->zmax );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDepthBoundsdNV( void *args )
{
    struct glDepthBoundsdNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDepthBoundsdNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthBoundsdNV( params->zmin, params->zmax );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDepthRangeArraydvNV( void *args )
{
    struct glDepthRangeArraydvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDepthRangeArraydvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangeArraydvNV( params->first, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDepthRangeArrayv( void *args )
{
    struct glDepthRangeArrayv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDepthRangeArrayv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangeArrayv( params->first, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDepthRangeIndexed( void *args )
{
    struct glDepthRangeIndexed_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDepthRangeIndexed) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangeIndexed( params->index, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDepthRangeIndexeddNV( void *args )
{
    struct glDepthRangeIndexeddNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDepthRangeIndexeddNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangeIndexeddNV( params->index, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDepthRangedNV( void *args )
{
    struct glDepthRangedNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDepthRangedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangedNV( params->zNear, params->zFar );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDepthRangef( void *args )
{
    struct glDepthRangef_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDepthRangef) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangef( params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDepthRangefOES( void *args )
{
    struct glDepthRangefOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDepthRangefOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangefOES( params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDepthRangex( void *args )
{
    struct glDepthRangex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDepthRangex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangex( params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDepthRangexOES( void *args )
{
    struct glDepthRangexOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDepthRangexOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangexOES( params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDetachObjectARB( void *args )
{
    struct glDetachObjectARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDetachObjectARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDetachObjectARB( params->containerObj, params->attachedObj );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDetachShader( void *args )
{
    struct glDetachShader_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDetachShader) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDetachShader( params->program, params->shader );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDetailTexFuncSGIS( void *args )
{
    struct glDetailTexFuncSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDetailTexFuncSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDetailTexFuncSGIS( params->target, params->n, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDisableClientStateIndexedEXT( void *args )
{
    struct glDisableClientStateIndexedEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDisableClientStateIndexedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableClientStateIndexedEXT( params->array, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDisableClientStateiEXT( void *args )
{
    struct glDisableClientStateiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDisableClientStateiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableClientStateiEXT( params->array, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDisableIndexedEXT( void *args )
{
    struct glDisableIndexedEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDisableIndexedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableIndexedEXT( params->target, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDisableVariantClientStateEXT( void *args )
{
    struct glDisableVariantClientStateEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDisableVariantClientStateEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableVariantClientStateEXT( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDisableVertexArrayAttrib( void *args )
{
    struct glDisableVertexArrayAttrib_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDisableVertexArrayAttrib) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableVertexArrayAttrib( params->vaobj, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDisableVertexArrayAttribEXT( void *args )
{
    struct glDisableVertexArrayAttribEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDisableVertexArrayAttribEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableVertexArrayAttribEXT( params->vaobj, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDisableVertexArrayEXT( void *args )
{
    struct glDisableVertexArrayEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDisableVertexArrayEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableVertexArrayEXT( params->vaobj, params->array );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDisableVertexAttribAPPLE( void *args )
{
    struct glDisableVertexAttribAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDisableVertexAttribAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableVertexAttribAPPLE( params->index, params->pname );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDisableVertexAttribArray( void *args )
{
    struct glDisableVertexAttribArray_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDisableVertexAttribArray) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableVertexAttribArray( params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDisableVertexAttribArrayARB( void *args )
{
    struct glDisableVertexAttribArrayARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDisableVertexAttribArrayARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableVertexAttribArrayARB( params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDisablei( void *args )
{
    struct glDisablei_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDisablei) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisablei( params->target, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDispatchCompute( void *args )
{
    struct glDispatchCompute_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDispatchCompute) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDispatchCompute( params->num_groups_x, params->num_groups_y, params->num_groups_z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDispatchComputeGroupSizeARB( void *args )
{
    struct glDispatchComputeGroupSizeARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDispatchComputeGroupSizeARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDispatchComputeGroupSizeARB( params->num_groups_x, params->num_groups_y, params->num_groups_z, params->group_size_x, params->group_size_y, params->group_size_z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDispatchComputeIndirect( void *args )
{
    struct glDispatchComputeIndirect_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDispatchComputeIndirect) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDispatchComputeIndirect( params->indirect );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawArraysEXT( void *args )
{
    struct glDrawArraysEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawArraysEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawArraysEXT( params->mode, params->first, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawArraysIndirect( void *args )
{
    struct glDrawArraysIndirect_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawArraysIndirect) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawArraysIndirect( params->mode, params->indirect );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawArraysInstanced( void *args )
{
    struct glDrawArraysInstanced_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawArraysInstanced) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawArraysInstanced( params->mode, params->first, params->count, params->instancecount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawArraysInstancedARB( void *args )
{
    struct glDrawArraysInstancedARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawArraysInstancedARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawArraysInstancedARB( params->mode, params->first, params->count, params->primcount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawArraysInstancedBaseInstance( void *args )
{
    struct glDrawArraysInstancedBaseInstance_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawArraysInstancedBaseInstance) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawArraysInstancedBaseInstance( params->mode, params->first, params->count, params->instancecount, params->baseinstance );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawArraysInstancedEXT( void *args )
{
    struct glDrawArraysInstancedEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawArraysInstancedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawArraysInstancedEXT( params->mode, params->start, params->count, params->primcount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawBufferRegion( void *args )
{
    struct glDrawBufferRegion_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawBufferRegion) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawBufferRegion( params->region, params->x, params->y, params->width, params->height, params->xDest, params->yDest );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawBuffers( void *args )
{
    struct glDrawBuffers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawBuffers) return STATUS_NOT_IMPLEMENTED;
    wrap_glDrawBuffers( params->teb, params->n, params->bufs, funcs->p_glDrawBuffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawBuffersARB( void *args )
{
    struct glDrawBuffersARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawBuffersARB) return STATUS_NOT_IMPLEMENTED;
    wrap_glDrawBuffers( params->teb, params->n, params->bufs, funcs->p_glDrawBuffersARB );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawBuffersATI( void *args )
{
    struct glDrawBuffersATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawBuffersATI) return STATUS_NOT_IMPLEMENTED;
    wrap_glDrawBuffers( params->teb, params->n, params->bufs, funcs->p_glDrawBuffersATI );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawCommandsAddressNV( void *args )
{
    struct glDrawCommandsAddressNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawCommandsAddressNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawCommandsAddressNV( params->primitiveMode, params->indirects, params->sizes, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawCommandsNV( void *args )
{
    struct glDrawCommandsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawCommandsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawCommandsNV( params->primitiveMode, params->buffer, params->indirects, params->sizes, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawCommandsStatesAddressNV( void *args )
{
    struct glDrawCommandsStatesAddressNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawCommandsStatesAddressNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawCommandsStatesAddressNV( params->indirects, params->sizes, params->states, params->fbos, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawCommandsStatesNV( void *args )
{
    struct glDrawCommandsStatesNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawCommandsStatesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawCommandsStatesNV( params->buffer, params->indirects, params->sizes, params->states, params->fbos, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawElementArrayAPPLE( void *args )
{
    struct glDrawElementArrayAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawElementArrayAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementArrayAPPLE( params->mode, params->first, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawElementArrayATI( void *args )
{
    struct glDrawElementArrayATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawElementArrayATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementArrayATI( params->mode, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawElementsBaseVertex( void *args )
{
    struct glDrawElementsBaseVertex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawElementsBaseVertex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementsBaseVertex( params->mode, params->count, params->type, params->indices, params->basevertex );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawElementsIndirect( void *args )
{
    struct glDrawElementsIndirect_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawElementsIndirect) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementsIndirect( params->mode, params->type, params->indirect );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawElementsInstanced( void *args )
{
    struct glDrawElementsInstanced_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawElementsInstanced) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementsInstanced( params->mode, params->count, params->type, params->indices, params->instancecount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawElementsInstancedARB( void *args )
{
    struct glDrawElementsInstancedARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawElementsInstancedARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementsInstancedARB( params->mode, params->count, params->type, params->indices, params->primcount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawElementsInstancedBaseInstance( void *args )
{
    struct glDrawElementsInstancedBaseInstance_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawElementsInstancedBaseInstance) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementsInstancedBaseInstance( params->mode, params->count, params->type, params->indices, params->instancecount, params->baseinstance );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawElementsInstancedBaseVertex( void *args )
{
    struct glDrawElementsInstancedBaseVertex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawElementsInstancedBaseVertex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementsInstancedBaseVertex( params->mode, params->count, params->type, params->indices, params->instancecount, params->basevertex );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawElementsInstancedBaseVertexBaseInstance( void *args )
{
    struct glDrawElementsInstancedBaseVertexBaseInstance_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawElementsInstancedBaseVertexBaseInstance) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementsInstancedBaseVertexBaseInstance( params->mode, params->count, params->type, params->indices, params->instancecount, params->basevertex, params->baseinstance );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawElementsInstancedEXT( void *args )
{
    struct glDrawElementsInstancedEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawElementsInstancedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementsInstancedEXT( params->mode, params->count, params->type, params->indices, params->primcount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawMeshArraysSUN( void *args )
{
    struct glDrawMeshArraysSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawMeshArraysSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawMeshArraysSUN( params->mode, params->first, params->count, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawMeshTasksEXT( void *args )
{
    struct glDrawMeshTasksEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawMeshTasksEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawMeshTasksEXT( params->num_groups_x, params->num_groups_y, params->num_groups_z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawMeshTasksIndirectEXT( void *args )
{
    struct glDrawMeshTasksIndirectEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawMeshTasksIndirectEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawMeshTasksIndirectEXT( params->indirect );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawMeshTasksIndirectNV( void *args )
{
    struct glDrawMeshTasksIndirectNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawMeshTasksIndirectNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawMeshTasksIndirectNV( params->indirect );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawMeshTasksNV( void *args )
{
    struct glDrawMeshTasksNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawMeshTasksNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawMeshTasksNV( params->first, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawRangeElementArrayAPPLE( void *args )
{
    struct glDrawRangeElementArrayAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawRangeElementArrayAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawRangeElementArrayAPPLE( params->mode, params->start, params->end, params->first, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawRangeElementArrayATI( void *args )
{
    struct glDrawRangeElementArrayATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawRangeElementArrayATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawRangeElementArrayATI( params->mode, params->start, params->end, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawRangeElements( void *args )
{
    struct glDrawRangeElements_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawRangeElements) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawRangeElements( params->mode, params->start, params->end, params->count, params->type, params->indices );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawRangeElementsBaseVertex( void *args )
{
    struct glDrawRangeElementsBaseVertex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawRangeElementsBaseVertex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawRangeElementsBaseVertex( params->mode, params->start, params->end, params->count, params->type, params->indices, params->basevertex );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawRangeElementsEXT( void *args )
{
    struct glDrawRangeElementsEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawRangeElementsEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawRangeElementsEXT( params->mode, params->start, params->end, params->count, params->type, params->indices );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawTextureNV( void *args )
{
    struct glDrawTextureNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawTextureNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawTextureNV( params->texture, params->sampler, params->x0, params->y0, params->x1, params->y1, params->z, params->s0, params->t0, params->s1, params->t1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawTransformFeedback( void *args )
{
    struct glDrawTransformFeedback_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawTransformFeedback) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawTransformFeedback( params->mode, params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawTransformFeedbackInstanced( void *args )
{
    struct glDrawTransformFeedbackInstanced_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawTransformFeedbackInstanced) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawTransformFeedbackInstanced( params->mode, params->id, params->instancecount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawTransformFeedbackNV( void *args )
{
    struct glDrawTransformFeedbackNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawTransformFeedbackNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawTransformFeedbackNV( params->mode, params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawTransformFeedbackStream( void *args )
{
    struct glDrawTransformFeedbackStream_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawTransformFeedbackStream) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawTransformFeedbackStream( params->mode, params->id, params->stream );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawTransformFeedbackStreamInstanced( void *args )
{
    struct glDrawTransformFeedbackStreamInstanced_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawTransformFeedbackStreamInstanced) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawTransformFeedbackStreamInstanced( params->mode, params->id, params->stream, params->instancecount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glDrawVkImageNV( void *args )
{
    struct glDrawVkImageNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glDrawVkImageNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawVkImageNV( params->vkImage, params->sampler, params->x0, params->y0, params->x1, params->y1, params->z, params->s0, params->t0, params->s1, params->t1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEGLImageTargetTexStorageEXT( void *args )
{
    struct glEGLImageTargetTexStorageEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEGLImageTargetTexStorageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEGLImageTargetTexStorageEXT( params->target, params->image, params->attrib_list );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEGLImageTargetTextureStorageEXT( void *args )
{
    struct glEGLImageTargetTextureStorageEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEGLImageTargetTextureStorageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEGLImageTargetTextureStorageEXT( params->texture, params->image, params->attrib_list );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEdgeFlagFormatNV( void *args )
{
    struct glEdgeFlagFormatNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEdgeFlagFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEdgeFlagFormatNV( params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEdgeFlagPointerEXT( void *args )
{
    struct glEdgeFlagPointerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEdgeFlagPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEdgeFlagPointerEXT( params->stride, params->count, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEdgeFlagPointerListIBM( void *args )
{
    struct glEdgeFlagPointerListIBM_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEdgeFlagPointerListIBM) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEdgeFlagPointerListIBM( params->stride, params->pointer, params->ptrstride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glElementPointerAPPLE( void *args )
{
    struct glElementPointerAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glElementPointerAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glElementPointerAPPLE( params->type, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glElementPointerATI( void *args )
{
    struct glElementPointerATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glElementPointerATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glElementPointerATI( params->type, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEnableClientStateIndexedEXT( void *args )
{
    struct glEnableClientStateIndexedEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEnableClientStateIndexedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableClientStateIndexedEXT( params->array, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEnableClientStateiEXT( void *args )
{
    struct glEnableClientStateiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEnableClientStateiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableClientStateiEXT( params->array, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEnableIndexedEXT( void *args )
{
    struct glEnableIndexedEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEnableIndexedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableIndexedEXT( params->target, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEnableVariantClientStateEXT( void *args )
{
    struct glEnableVariantClientStateEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEnableVariantClientStateEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableVariantClientStateEXT( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEnableVertexArrayAttrib( void *args )
{
    struct glEnableVertexArrayAttrib_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEnableVertexArrayAttrib) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableVertexArrayAttrib( params->vaobj, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEnableVertexArrayAttribEXT( void *args )
{
    struct glEnableVertexArrayAttribEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEnableVertexArrayAttribEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableVertexArrayAttribEXT( params->vaobj, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEnableVertexArrayEXT( void *args )
{
    struct glEnableVertexArrayEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEnableVertexArrayEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableVertexArrayEXT( params->vaobj, params->array );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEnableVertexAttribAPPLE( void *args )
{
    struct glEnableVertexAttribAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEnableVertexAttribAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableVertexAttribAPPLE( params->index, params->pname );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEnableVertexAttribArray( void *args )
{
    struct glEnableVertexAttribArray_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEnableVertexAttribArray) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableVertexAttribArray( params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEnableVertexAttribArrayARB( void *args )
{
    struct glEnableVertexAttribArrayARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEnableVertexAttribArrayARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableVertexAttribArrayARB( params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEnablei( void *args )
{
    struct glEnablei_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEnablei) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnablei( params->target, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEndConditionalRender( void *args )
{
    struct glEndConditionalRender_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEndConditionalRender) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndConditionalRender();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEndConditionalRenderNV( void *args )
{
    struct glEndConditionalRenderNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEndConditionalRenderNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndConditionalRenderNV();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEndConditionalRenderNVX( void *args )
{
    struct glEndConditionalRenderNVX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEndConditionalRenderNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndConditionalRenderNVX();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEndFragmentShaderATI( void *args )
{
    struct glEndFragmentShaderATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEndFragmentShaderATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndFragmentShaderATI();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEndOcclusionQueryNV( void *args )
{
    struct glEndOcclusionQueryNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEndOcclusionQueryNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndOcclusionQueryNV();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEndPerfMonitorAMD( void *args )
{
    struct glEndPerfMonitorAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEndPerfMonitorAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndPerfMonitorAMD( params->monitor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEndPerfQueryINTEL( void *args )
{
    struct glEndPerfQueryINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEndPerfQueryINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndPerfQueryINTEL( params->queryHandle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEndQuery( void *args )
{
    struct glEndQuery_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEndQuery) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndQuery( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEndQueryARB( void *args )
{
    struct glEndQueryARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEndQueryARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndQueryARB( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEndQueryIndexed( void *args )
{
    struct glEndQueryIndexed_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEndQueryIndexed) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndQueryIndexed( params->target, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEndTransformFeedback( void *args )
{
    struct glEndTransformFeedback_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEndTransformFeedback) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndTransformFeedback();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEndTransformFeedbackEXT( void *args )
{
    struct glEndTransformFeedbackEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEndTransformFeedbackEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndTransformFeedbackEXT();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEndTransformFeedbackNV( void *args )
{
    struct glEndTransformFeedbackNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEndTransformFeedbackNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndTransformFeedbackNV();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEndVertexShaderEXT( void *args )
{
    struct glEndVertexShaderEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEndVertexShaderEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndVertexShaderEXT();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEndVideoCaptureNV( void *args )
{
    struct glEndVideoCaptureNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEndVideoCaptureNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndVideoCaptureNV( params->video_capture_slot );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEvalCoord1xOES( void *args )
{
    struct glEvalCoord1xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalCoord1xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord1xOES( params->u );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEvalCoord1xvOES( void *args )
{
    struct glEvalCoord1xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalCoord1xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord1xvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEvalCoord2xOES( void *args )
{
    struct glEvalCoord2xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalCoord2xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord2xOES( params->u, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEvalCoord2xvOES( void *args )
{
    struct glEvalCoord2xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalCoord2xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord2xvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEvalMapsNV( void *args )
{
    struct glEvalMapsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvalMapsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalMapsNV( params->target, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glEvaluateDepthValuesARB( void *args )
{
    struct glEvaluateDepthValuesARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glEvaluateDepthValuesARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvaluateDepthValuesARB();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glExecuteProgramNV( void *args )
{
    struct glExecuteProgramNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glExecuteProgramNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glExecuteProgramNV( params->target, params->id, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glExtractComponentEXT( void *args )
{
    struct glExtractComponentEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glExtractComponentEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glExtractComponentEXT( params->res, params->src, params->num );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFeedbackBufferxOES( void *args )
{
    struct glFeedbackBufferxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFeedbackBufferxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFeedbackBufferxOES( params->n, params->type, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFenceSync( void *args )
{
    struct glFenceSync_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFenceSync) return STATUS_NOT_IMPLEMENTED;
    params->ret = wrap_glFenceSync( params->teb, params->condition, params->flags, params->ret, funcs->p_glFenceSync );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFinalCombinerInputNV( void *args )
{
    struct glFinalCombinerInputNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFinalCombinerInputNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFinalCombinerInputNV( params->variable, params->input, params->mapping, params->componentUsage );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFinishAsyncSGIX( void *args )
{
    struct glFinishAsyncSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFinishAsyncSGIX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glFinishAsyncSGIX( params->markerp );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFinishFenceAPPLE( void *args )
{
    struct glFinishFenceAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFinishFenceAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFinishFenceAPPLE( params->fence );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFinishFenceNV( void *args )
{
    struct glFinishFenceNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFinishFenceNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFinishFenceNV( params->fence );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFinishObjectAPPLE( void *args )
{
    struct glFinishObjectAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFinishObjectAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFinishObjectAPPLE( params->object, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFinishTextureSUNX( void *args )
{
    struct glFinishTextureSUNX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFinishTextureSUNX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFinishTextureSUNX();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFlushMappedBufferRange( void *args )
{
    struct glFlushMappedBufferRange_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFlushMappedBufferRange) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFlushMappedBufferRange( params->target, params->offset, params->length );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFlushMappedBufferRangeAPPLE( void *args )
{
    struct glFlushMappedBufferRangeAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFlushMappedBufferRangeAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFlushMappedBufferRangeAPPLE( params->target, params->offset, params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFlushMappedNamedBufferRange( void *args )
{
    struct glFlushMappedNamedBufferRange_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFlushMappedNamedBufferRange) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFlushMappedNamedBufferRange( params->buffer, params->offset, params->length );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFlushMappedNamedBufferRangeEXT( void *args )
{
    struct glFlushMappedNamedBufferRangeEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFlushMappedNamedBufferRangeEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFlushMappedNamedBufferRangeEXT( params->buffer, params->offset, params->length );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFlushPixelDataRangeNV( void *args )
{
    struct glFlushPixelDataRangeNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFlushPixelDataRangeNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFlushPixelDataRangeNV( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFlushRasterSGIX( void *args )
{
    struct glFlushRasterSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFlushRasterSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFlushRasterSGIX();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFlushStaticDataIBM( void *args )
{
    struct glFlushStaticDataIBM_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFlushStaticDataIBM) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFlushStaticDataIBM( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFlushVertexArrayRangeAPPLE( void *args )
{
    struct glFlushVertexArrayRangeAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFlushVertexArrayRangeAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFlushVertexArrayRangeAPPLE( params->length, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFlushVertexArrayRangeNV( void *args )
{
    struct glFlushVertexArrayRangeNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFlushVertexArrayRangeNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFlushVertexArrayRangeNV();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogCoordFormatNV( void *args )
{
    struct glFogCoordFormatNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogCoordFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordFormatNV( params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogCoordPointer( void *args )
{
    struct glFogCoordPointer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogCoordPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordPointer( params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogCoordPointerEXT( void *args )
{
    struct glFogCoordPointerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogCoordPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordPointerEXT( params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogCoordPointerListIBM( void *args )
{
    struct glFogCoordPointerListIBM_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogCoordPointerListIBM) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordPointerListIBM( params->type, params->stride, params->pointer, params->ptrstride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogCoordd( void *args )
{
    struct glFogCoordd_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogCoordd) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordd( params->coord );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogCoorddEXT( void *args )
{
    struct glFogCoorddEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogCoorddEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoorddEXT( params->coord );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogCoorddv( void *args )
{
    struct glFogCoorddv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogCoorddv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoorddv( params->coord );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogCoorddvEXT( void *args )
{
    struct glFogCoorddvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogCoorddvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoorddvEXT( params->coord );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogCoordf( void *args )
{
    struct glFogCoordf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogCoordf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordf( params->coord );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogCoordfEXT( void *args )
{
    struct glFogCoordfEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogCoordfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordfEXT( params->coord );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogCoordfv( void *args )
{
    struct glFogCoordfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogCoordfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordfv( params->coord );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogCoordfvEXT( void *args )
{
    struct glFogCoordfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogCoordfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordfvEXT( params->coord );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogCoordhNV( void *args )
{
    struct glFogCoordhNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogCoordhNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordhNV( params->fog );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogCoordhvNV( void *args )
{
    struct glFogCoordhvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogCoordhvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordhvNV( params->fog );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogFuncSGIS( void *args )
{
    struct glFogFuncSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogFuncSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogFuncSGIS( params->n, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogx( void *args )
{
    struct glFogx_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogx( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogxOES( void *args )
{
    struct glFogxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogxOES( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogxv( void *args )
{
    struct glFogxv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogxv( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFogxvOES( void *args )
{
    struct glFogxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFogxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogxvOES( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFragmentColorMaterialSGIX( void *args )
{
    struct glFragmentColorMaterialSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFragmentColorMaterialSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentColorMaterialSGIX( params->face, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFragmentCoverageColorNV( void *args )
{
    struct glFragmentCoverageColorNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFragmentCoverageColorNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentCoverageColorNV( params->color );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFragmentLightModelfSGIX( void *args )
{
    struct glFragmentLightModelfSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFragmentLightModelfSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentLightModelfSGIX( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFragmentLightModelfvSGIX( void *args )
{
    struct glFragmentLightModelfvSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFragmentLightModelfvSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentLightModelfvSGIX( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFragmentLightModeliSGIX( void *args )
{
    struct glFragmentLightModeliSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFragmentLightModeliSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentLightModeliSGIX( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFragmentLightModelivSGIX( void *args )
{
    struct glFragmentLightModelivSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFragmentLightModelivSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentLightModelivSGIX( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFragmentLightfSGIX( void *args )
{
    struct glFragmentLightfSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFragmentLightfSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentLightfSGIX( params->light, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFragmentLightfvSGIX( void *args )
{
    struct glFragmentLightfvSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFragmentLightfvSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentLightfvSGIX( params->light, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFragmentLightiSGIX( void *args )
{
    struct glFragmentLightiSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFragmentLightiSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentLightiSGIX( params->light, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFragmentLightivSGIX( void *args )
{
    struct glFragmentLightivSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFragmentLightivSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentLightivSGIX( params->light, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFragmentMaterialfSGIX( void *args )
{
    struct glFragmentMaterialfSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFragmentMaterialfSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentMaterialfSGIX( params->face, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFragmentMaterialfvSGIX( void *args )
{
    struct glFragmentMaterialfvSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFragmentMaterialfvSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentMaterialfvSGIX( params->face, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFragmentMaterialiSGIX( void *args )
{
    struct glFragmentMaterialiSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFragmentMaterialiSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentMaterialiSGIX( params->face, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFragmentMaterialivSGIX( void *args )
{
    struct glFragmentMaterialivSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFragmentMaterialivSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentMaterialivSGIX( params->face, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFrameTerminatorGREMEDY( void *args )
{
    struct glFrameTerminatorGREMEDY_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFrameTerminatorGREMEDY) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFrameTerminatorGREMEDY();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFrameZoomSGIX( void *args )
{
    struct glFrameZoomSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFrameZoomSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFrameZoomSGIX( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferDrawBufferEXT( void *args )
{
    struct glFramebufferDrawBufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferDrawBufferEXT) return STATUS_NOT_IMPLEMENTED;
    wrap_glFramebufferDrawBufferEXT( params->teb, params->framebuffer, params->mode, funcs->p_glFramebufferDrawBufferEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferDrawBuffersEXT( void *args )
{
    struct glFramebufferDrawBuffersEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferDrawBuffersEXT) return STATUS_NOT_IMPLEMENTED;
    wrap_glFramebufferDrawBuffersEXT( params->teb, params->framebuffer, params->n, params->bufs, funcs->p_glFramebufferDrawBuffersEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferFetchBarrierEXT( void *args )
{
    struct glFramebufferFetchBarrierEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferFetchBarrierEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFramebufferFetchBarrierEXT();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferParameteri( void *args )
{
    struct glFramebufferParameteri_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferParameteri) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFramebufferParameteri( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferParameteriMESA( void *args )
{
    struct glFramebufferParameteriMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferParameteriMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFramebufferParameteriMESA( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferReadBufferEXT( void *args )
{
    struct glFramebufferReadBufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferReadBufferEXT) return STATUS_NOT_IMPLEMENTED;
    wrap_glFramebufferReadBufferEXT( params->teb, params->framebuffer, params->mode, funcs->p_glFramebufferReadBufferEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferRenderbuffer( void *args )
{
    struct glFramebufferRenderbuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferRenderbuffer) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferRenderbuffer( params->target, params->attachment, params->renderbuffertarget, params->renderbuffer );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferRenderbufferEXT( void *args )
{
    struct glFramebufferRenderbufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferRenderbufferEXT) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferRenderbufferEXT( params->target, params->attachment, params->renderbuffertarget, params->renderbuffer );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferSampleLocationsfvARB( void *args )
{
    struct glFramebufferSampleLocationsfvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferSampleLocationsfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFramebufferSampleLocationsfvARB( params->target, params->start, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferSampleLocationsfvNV( void *args )
{
    struct glFramebufferSampleLocationsfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferSampleLocationsfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFramebufferSampleLocationsfvNV( params->target, params->start, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferSamplePositionsfvAMD( void *args )
{
    struct glFramebufferSamplePositionsfvAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferSamplePositionsfvAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFramebufferSamplePositionsfvAMD( params->target, params->numsamples, params->pixelindex, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferShadingRateEXT( void *args )
{
    struct glFramebufferShadingRateEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferShadingRateEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFramebufferShadingRateEXT( params->target, params->attachment, params->texture, params->baseLayer, params->numLayers, params->texelWidth, params->texelHeight );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferTexture( void *args )
{
    struct glFramebufferTexture_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferTexture) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferTexture( params->target, params->attachment, params->texture, params->level );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferTexture1D( void *args )
{
    struct glFramebufferTexture1D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferTexture1D) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferTexture1D( params->target, params->attachment, params->textarget, params->texture, params->level );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferTexture1DEXT( void *args )
{
    struct glFramebufferTexture1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferTexture1DEXT) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferTexture1DEXT( params->target, params->attachment, params->textarget, params->texture, params->level );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferTexture2D( void *args )
{
    struct glFramebufferTexture2D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferTexture2D) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferTexture2D( params->target, params->attachment, params->textarget, params->texture, params->level );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferTexture2DEXT( void *args )
{
    struct glFramebufferTexture2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferTexture2DEXT) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferTexture2DEXT( params->target, params->attachment, params->textarget, params->texture, params->level );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferTexture3D( void *args )
{
    struct glFramebufferTexture3D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferTexture3D) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferTexture3D( params->target, params->attachment, params->textarget, params->texture, params->level, params->zoffset );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferTexture3DEXT( void *args )
{
    struct glFramebufferTexture3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferTexture3DEXT) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferTexture3DEXT( params->target, params->attachment, params->textarget, params->texture, params->level, params->zoffset );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferTextureARB( void *args )
{
    struct glFramebufferTextureARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferTextureARB) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferTextureARB( params->target, params->attachment, params->texture, params->level );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferTextureEXT( void *args )
{
    struct glFramebufferTextureEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferTextureEXT) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferTextureEXT( params->target, params->attachment, params->texture, params->level );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferTextureFaceARB( void *args )
{
    struct glFramebufferTextureFaceARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferTextureFaceARB) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferTextureFaceARB( params->target, params->attachment, params->texture, params->level, params->face );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferTextureFaceEXT( void *args )
{
    struct glFramebufferTextureFaceEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferTextureFaceEXT) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferTextureFaceEXT( params->target, params->attachment, params->texture, params->level, params->face );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferTextureLayer( void *args )
{
    struct glFramebufferTextureLayer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferTextureLayer) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferTextureLayer( params->target, params->attachment, params->texture, params->level, params->layer );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferTextureLayerARB( void *args )
{
    struct glFramebufferTextureLayerARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferTextureLayerARB) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferTextureLayerARB( params->target, params->attachment, params->texture, params->level, params->layer );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferTextureLayerEXT( void *args )
{
    struct glFramebufferTextureLayerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferTextureLayerEXT) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferTextureLayerEXT( params->target, params->attachment, params->texture, params->level, params->layer );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFramebufferTextureMultiviewOVR( void *args )
{
    struct glFramebufferTextureMultiviewOVR_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFramebufferTextureMultiviewOVR) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glFramebufferTextureMultiviewOVR( params->target, params->attachment, params->texture, params->level, params->baseViewIndex, params->numViews );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFreeObjectBufferATI( void *args )
{
    struct glFreeObjectBufferATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFreeObjectBufferATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFreeObjectBufferATI( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFrustumf( void *args )
{
    struct glFrustumf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFrustumf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFrustumf( params->l, params->r, params->b, params->t, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFrustumfOES( void *args )
{
    struct glFrustumfOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFrustumfOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFrustumfOES( params->l, params->r, params->b, params->t, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFrustumx( void *args )
{
    struct glFrustumx_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFrustumx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFrustumx( params->l, params->r, params->b, params->t, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glFrustumxOES( void *args )
{
    struct glFrustumxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glFrustumxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFrustumxOES( params->l, params->r, params->b, params->t, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenAsyncMarkersSGIX( void *args )
{
    struct glGenAsyncMarkersSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenAsyncMarkersSGIX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGenAsyncMarkersSGIX( params->range );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenBuffers( void *args )
{
    struct glGenBuffers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenBuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenBuffers( params->n, params->buffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenBuffersARB( void *args )
{
    struct glGenBuffersARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenBuffersARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenBuffersARB( params->n, params->buffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenFencesAPPLE( void *args )
{
    struct glGenFencesAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenFencesAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenFencesAPPLE( params->n, params->fences );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenFencesNV( void *args )
{
    struct glGenFencesNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenFencesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenFencesNV( params->n, params->fences );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenFragmentShadersATI( void *args )
{
    struct glGenFragmentShadersATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenFragmentShadersATI) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGenFragmentShadersATI( params->range );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenFramebuffers( void *args )
{
    struct glGenFramebuffers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenFramebuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenFramebuffers( params->n, params->framebuffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenFramebuffersEXT( void *args )
{
    struct glGenFramebuffersEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenFramebuffersEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenFramebuffersEXT( params->n, params->framebuffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenNamesAMD( void *args )
{
    struct glGenNamesAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenNamesAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenNamesAMD( params->identifier, params->num, params->names );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenOcclusionQueriesNV( void *args )
{
    struct glGenOcclusionQueriesNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenOcclusionQueriesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenOcclusionQueriesNV( params->n, params->ids );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenPathsNV( void *args )
{
    struct glGenPathsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenPathsNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGenPathsNV( params->range );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenPerfMonitorsAMD( void *args )
{
    struct glGenPerfMonitorsAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenPerfMonitorsAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenPerfMonitorsAMD( params->n, params->monitors );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenProgramPipelines( void *args )
{
    struct glGenProgramPipelines_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenProgramPipelines) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenProgramPipelines( params->n, params->pipelines );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenProgramsARB( void *args )
{
    struct glGenProgramsARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenProgramsARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenProgramsARB( params->n, params->programs );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenProgramsNV( void *args )
{
    struct glGenProgramsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenProgramsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenProgramsNV( params->n, params->programs );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenQueries( void *args )
{
    struct glGenQueries_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenQueries) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenQueries( params->n, params->ids );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenQueriesARB( void *args )
{
    struct glGenQueriesARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenQueriesARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenQueriesARB( params->n, params->ids );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenQueryResourceTagNV( void *args )
{
    struct glGenQueryResourceTagNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenQueryResourceTagNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenQueryResourceTagNV( params->n, params->tagIds );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenRenderbuffers( void *args )
{
    struct glGenRenderbuffers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenRenderbuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenRenderbuffers( params->n, params->renderbuffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenRenderbuffersEXT( void *args )
{
    struct glGenRenderbuffersEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenRenderbuffersEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenRenderbuffersEXT( params->n, params->renderbuffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenSamplers( void *args )
{
    struct glGenSamplers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenSamplers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenSamplers( params->count, params->samplers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenSemaphoresEXT( void *args )
{
    struct glGenSemaphoresEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenSemaphoresEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenSemaphoresEXT( params->n, params->semaphores );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenSymbolsEXT( void *args )
{
    struct glGenSymbolsEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenSymbolsEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGenSymbolsEXT( params->datatype, params->storagetype, params->range, params->components );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenTexturesEXT( void *args )
{
    struct glGenTexturesEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenTexturesEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenTexturesEXT( params->n, params->textures );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenTransformFeedbacks( void *args )
{
    struct glGenTransformFeedbacks_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenTransformFeedbacks) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenTransformFeedbacks( params->n, params->ids );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenTransformFeedbacksNV( void *args )
{
    struct glGenTransformFeedbacksNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenTransformFeedbacksNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenTransformFeedbacksNV( params->n, params->ids );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenVertexArrays( void *args )
{
    struct glGenVertexArrays_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenVertexArrays) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenVertexArrays( params->n, params->arrays );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenVertexArraysAPPLE( void *args )
{
    struct glGenVertexArraysAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenVertexArraysAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenVertexArraysAPPLE( params->n, params->arrays );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenVertexShadersEXT( void *args )
{
    struct glGenVertexShadersEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenVertexShadersEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGenVertexShadersEXT( params->range );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenerateMipmap( void *args )
{
    struct glGenerateMipmap_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenerateMipmap) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenerateMipmap( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenerateMipmapEXT( void *args )
{
    struct glGenerateMipmapEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenerateMipmapEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenerateMipmapEXT( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenerateMultiTexMipmapEXT( void *args )
{
    struct glGenerateMultiTexMipmapEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenerateMultiTexMipmapEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenerateMultiTexMipmapEXT( params->texunit, params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenerateTextureMipmap( void *args )
{
    struct glGenerateTextureMipmap_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenerateTextureMipmap) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenerateTextureMipmap( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGenerateTextureMipmapEXT( void *args )
{
    struct glGenerateTextureMipmapEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGenerateTextureMipmapEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenerateTextureMipmapEXT( params->texture, params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetActiveAtomicCounterBufferiv( void *args )
{
    struct glGetActiveAtomicCounterBufferiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetActiveAtomicCounterBufferiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveAtomicCounterBufferiv( params->program, params->bufferIndex, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetActiveAttrib( void *args )
{
    struct glGetActiveAttrib_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetActiveAttrib) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveAttrib( params->program, params->index, params->bufSize, params->length, params->size, params->type, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetActiveAttribARB( void *args )
{
    struct glGetActiveAttribARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetActiveAttribARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveAttribARB( params->programObj, params->index, params->maxLength, params->length, params->size, params->type, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetActiveSubroutineName( void *args )
{
    struct glGetActiveSubroutineName_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetActiveSubroutineName) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveSubroutineName( params->program, params->shadertype, params->index, params->bufSize, params->length, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetActiveSubroutineUniformName( void *args )
{
    struct glGetActiveSubroutineUniformName_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetActiveSubroutineUniformName) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveSubroutineUniformName( params->program, params->shadertype, params->index, params->bufSize, params->length, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetActiveSubroutineUniformiv( void *args )
{
    struct glGetActiveSubroutineUniformiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetActiveSubroutineUniformiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveSubroutineUniformiv( params->program, params->shadertype, params->index, params->pname, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetActiveUniform( void *args )
{
    struct glGetActiveUniform_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetActiveUniform) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveUniform( params->program, params->index, params->bufSize, params->length, params->size, params->type, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetActiveUniformARB( void *args )
{
    struct glGetActiveUniformARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetActiveUniformARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveUniformARB( params->programObj, params->index, params->maxLength, params->length, params->size, params->type, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetActiveUniformBlockName( void *args )
{
    struct glGetActiveUniformBlockName_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetActiveUniformBlockName) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveUniformBlockName( params->program, params->uniformBlockIndex, params->bufSize, params->length, params->uniformBlockName );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetActiveUniformBlockiv( void *args )
{
    struct glGetActiveUniformBlockiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetActiveUniformBlockiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveUniformBlockiv( params->program, params->uniformBlockIndex, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetActiveUniformName( void *args )
{
    struct glGetActiveUniformName_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetActiveUniformName) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveUniformName( params->program, params->uniformIndex, params->bufSize, params->length, params->uniformName );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetActiveUniformsiv( void *args )
{
    struct glGetActiveUniformsiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetActiveUniformsiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveUniformsiv( params->program, params->uniformCount, params->uniformIndices, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetActiveVaryingNV( void *args )
{
    struct glGetActiveVaryingNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetActiveVaryingNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveVaryingNV( params->program, params->index, params->bufSize, params->length, params->size, params->type, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetArrayObjectfvATI( void *args )
{
    struct glGetArrayObjectfvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetArrayObjectfvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetArrayObjectfvATI( params->array, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetArrayObjectivATI( void *args )
{
    struct glGetArrayObjectivATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetArrayObjectivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetArrayObjectivATI( params->array, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetAttachedObjectsARB( void *args )
{
    struct glGetAttachedObjectsARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetAttachedObjectsARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetAttachedObjectsARB( params->containerObj, params->maxCount, params->count, params->obj );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetAttachedShaders( void *args )
{
    struct glGetAttachedShaders_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetAttachedShaders) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetAttachedShaders( params->program, params->maxCount, params->count, params->shaders );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetAttribLocation( void *args )
{
    struct glGetAttribLocation_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetAttribLocation) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetAttribLocation( params->program, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetAttribLocationARB( void *args )
{
    struct glGetAttribLocationARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetAttribLocationARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetAttribLocationARB( params->programObj, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetBooleanIndexedvEXT( void *args )
{
    struct glGetBooleanIndexedvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetBooleanIndexedvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBooleanIndexedvEXT( params->target, params->index, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetBooleani_v( void *args )
{
    struct glGetBooleani_v_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetBooleani_v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBooleani_v( params->target, params->index, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetBufferParameteri64v( void *args )
{
    struct glGetBufferParameteri64v_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetBufferParameteri64v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBufferParameteri64v( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetBufferParameteriv( void *args )
{
    struct glGetBufferParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetBufferParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBufferParameteriv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetBufferParameterivARB( void *args )
{
    struct glGetBufferParameterivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetBufferParameterivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBufferParameterivARB( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetBufferParameterui64vNV( void *args )
{
    struct glGetBufferParameterui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetBufferParameterui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBufferParameterui64vNV( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetBufferPointerv( void *args )
{
    struct glGetBufferPointerv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetBufferPointerv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBufferPointerv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetBufferPointervARB( void *args )
{
    struct glGetBufferPointervARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetBufferPointervARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBufferPointervARB( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetBufferSubData( void *args )
{
    struct glGetBufferSubData_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBufferSubData( params->target, params->offset, params->size, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetBufferSubDataARB( void *args )
{
    struct glGetBufferSubDataARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetBufferSubDataARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBufferSubDataARB( params->target, params->offset, params->size, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetClipPlanef( void *args )
{
    struct glGetClipPlanef_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetClipPlanef) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetClipPlanef( params->plane, params->equation );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetClipPlanefOES( void *args )
{
    struct glGetClipPlanefOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetClipPlanefOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetClipPlanefOES( params->plane, params->equation );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetClipPlanex( void *args )
{
    struct glGetClipPlanex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetClipPlanex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetClipPlanex( params->plane, params->equation );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetClipPlanexOES( void *args )
{
    struct glGetClipPlanexOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetClipPlanexOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetClipPlanexOES( params->plane, params->equation );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetColorTable( void *args )
{
    struct glGetColorTable_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetColorTable) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTable( params->target, params->format, params->type, params->table );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetColorTableEXT( void *args )
{
    struct glGetColorTableEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetColorTableEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTableEXT( params->target, params->format, params->type, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetColorTableParameterfv( void *args )
{
    struct glGetColorTableParameterfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetColorTableParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTableParameterfv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetColorTableParameterfvEXT( void *args )
{
    struct glGetColorTableParameterfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetColorTableParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTableParameterfvEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetColorTableParameterfvSGI( void *args )
{
    struct glGetColorTableParameterfvSGI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetColorTableParameterfvSGI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTableParameterfvSGI( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetColorTableParameteriv( void *args )
{
    struct glGetColorTableParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetColorTableParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTableParameteriv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetColorTableParameterivEXT( void *args )
{
    struct glGetColorTableParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetColorTableParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTableParameterivEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetColorTableParameterivSGI( void *args )
{
    struct glGetColorTableParameterivSGI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetColorTableParameterivSGI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTableParameterivSGI( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetColorTableSGI( void *args )
{
    struct glGetColorTableSGI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetColorTableSGI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTableSGI( params->target, params->format, params->type, params->table );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetCombinerInputParameterfvNV( void *args )
{
    struct glGetCombinerInputParameterfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetCombinerInputParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCombinerInputParameterfvNV( params->stage, params->portion, params->variable, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetCombinerInputParameterivNV( void *args )
{
    struct glGetCombinerInputParameterivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetCombinerInputParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCombinerInputParameterivNV( params->stage, params->portion, params->variable, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetCombinerOutputParameterfvNV( void *args )
{
    struct glGetCombinerOutputParameterfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetCombinerOutputParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCombinerOutputParameterfvNV( params->stage, params->portion, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetCombinerOutputParameterivNV( void *args )
{
    struct glGetCombinerOutputParameterivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetCombinerOutputParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCombinerOutputParameterivNV( params->stage, params->portion, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetCombinerStageParameterfvNV( void *args )
{
    struct glGetCombinerStageParameterfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetCombinerStageParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCombinerStageParameterfvNV( params->stage, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetCommandHeaderNV( void *args )
{
    struct glGetCommandHeaderNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetCommandHeaderNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetCommandHeaderNV( params->tokenID, params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetCompressedMultiTexImageEXT( void *args )
{
    struct glGetCompressedMultiTexImageEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetCompressedMultiTexImageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCompressedMultiTexImageEXT( params->texunit, params->target, params->lod, params->img );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetCompressedTexImage( void *args )
{
    struct glGetCompressedTexImage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetCompressedTexImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCompressedTexImage( params->target, params->level, params->img );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetCompressedTexImageARB( void *args )
{
    struct glGetCompressedTexImageARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetCompressedTexImageARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCompressedTexImageARB( params->target, params->level, params->img );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetCompressedTextureImage( void *args )
{
    struct glGetCompressedTextureImage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetCompressedTextureImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCompressedTextureImage( params->texture, params->level, params->bufSize, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetCompressedTextureImageEXT( void *args )
{
    struct glGetCompressedTextureImageEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetCompressedTextureImageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCompressedTextureImageEXT( params->texture, params->target, params->lod, params->img );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetCompressedTextureSubImage( void *args )
{
    struct glGetCompressedTextureSubImage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetCompressedTextureSubImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCompressedTextureSubImage( params->texture, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->bufSize, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetConvolutionFilter( void *args )
{
    struct glGetConvolutionFilter_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetConvolutionFilter) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetConvolutionFilter( params->target, params->format, params->type, params->image );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetConvolutionFilterEXT( void *args )
{
    struct glGetConvolutionFilterEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetConvolutionFilterEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetConvolutionFilterEXT( params->target, params->format, params->type, params->image );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetConvolutionParameterfv( void *args )
{
    struct glGetConvolutionParameterfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetConvolutionParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetConvolutionParameterfv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetConvolutionParameterfvEXT( void *args )
{
    struct glGetConvolutionParameterfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetConvolutionParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetConvolutionParameterfvEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetConvolutionParameteriv( void *args )
{
    struct glGetConvolutionParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetConvolutionParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetConvolutionParameteriv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetConvolutionParameterivEXT( void *args )
{
    struct glGetConvolutionParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetConvolutionParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetConvolutionParameterivEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetConvolutionParameterxvOES( void *args )
{
    struct glGetConvolutionParameterxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetConvolutionParameterxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetConvolutionParameterxvOES( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetCoverageModulationTableNV( void *args )
{
    struct glGetCoverageModulationTableNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetCoverageModulationTableNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCoverageModulationTableNV( params->bufSize, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetDebugMessageLog( void *args )
{
    struct glGetDebugMessageLog_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetDebugMessageLog) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetDebugMessageLog( params->count, params->bufSize, params->sources, params->types, params->ids, params->severities, params->lengths, params->messageLog );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetDebugMessageLogAMD( void *args )
{
    struct glGetDebugMessageLogAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetDebugMessageLogAMD) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetDebugMessageLogAMD( params->count, params->bufSize, params->categories, params->severities, params->ids, params->lengths, params->message );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetDebugMessageLogARB( void *args )
{
    struct glGetDebugMessageLogARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetDebugMessageLogARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetDebugMessageLogARB( params->count, params->bufSize, params->sources, params->types, params->ids, params->severities, params->lengths, params->messageLog );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetDetailTexFuncSGIS( void *args )
{
    struct glGetDetailTexFuncSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetDetailTexFuncSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetDetailTexFuncSGIS( params->target, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetDoubleIndexedvEXT( void *args )
{
    struct glGetDoubleIndexedvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetDoubleIndexedvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetDoubleIndexedvEXT( params->target, params->index, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetDoublei_v( void *args )
{
    struct glGetDoublei_v_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetDoublei_v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetDoublei_v( params->target, params->index, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetDoublei_vEXT( void *args )
{
    struct glGetDoublei_vEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetDoublei_vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetDoublei_vEXT( params->pname, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFenceivNV( void *args )
{
    struct glGetFenceivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFenceivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFenceivNV( params->fence, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFinalCombinerInputParameterfvNV( void *args )
{
    struct glGetFinalCombinerInputParameterfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFinalCombinerInputParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFinalCombinerInputParameterfvNV( params->variable, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFinalCombinerInputParameterivNV( void *args )
{
    struct glGetFinalCombinerInputParameterivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFinalCombinerInputParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFinalCombinerInputParameterivNV( params->variable, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFirstPerfQueryIdINTEL( void *args )
{
    struct glGetFirstPerfQueryIdINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFirstPerfQueryIdINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFirstPerfQueryIdINTEL( params->queryId );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFixedv( void *args )
{
    struct glGetFixedv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFixedv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFixedv( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFixedvOES( void *args )
{
    struct glGetFixedvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFixedvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFixedvOES( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFloatIndexedvEXT( void *args )
{
    struct glGetFloatIndexedvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFloatIndexedvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFloatIndexedvEXT( params->target, params->index, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFloati_v( void *args )
{
    struct glGetFloati_v_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFloati_v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFloati_v( params->target, params->index, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFloati_vEXT( void *args )
{
    struct glGetFloati_vEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFloati_vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFloati_vEXT( params->pname, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFogFuncSGIS( void *args )
{
    struct glGetFogFuncSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFogFuncSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFogFuncSGIS( params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFragDataIndex( void *args )
{
    struct glGetFragDataIndex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFragDataIndex) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetFragDataIndex( params->program, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFragDataLocation( void *args )
{
    struct glGetFragDataLocation_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFragDataLocation) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetFragDataLocation( params->program, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFragDataLocationEXT( void *args )
{
    struct glGetFragDataLocationEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFragDataLocationEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetFragDataLocationEXT( params->program, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFragmentLightfvSGIX( void *args )
{
    struct glGetFragmentLightfvSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFragmentLightfvSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFragmentLightfvSGIX( params->light, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFragmentLightivSGIX( void *args )
{
    struct glGetFragmentLightivSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFragmentLightivSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFragmentLightivSGIX( params->light, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFragmentMaterialfvSGIX( void *args )
{
    struct glGetFragmentMaterialfvSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFragmentMaterialfvSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFragmentMaterialfvSGIX( params->face, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFragmentMaterialivSGIX( void *args )
{
    struct glGetFragmentMaterialivSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFragmentMaterialivSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFragmentMaterialivSGIX( params->face, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFragmentShadingRatesEXT( void *args )
{
    struct glGetFragmentShadingRatesEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFragmentShadingRatesEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFragmentShadingRatesEXT( params->samples, params->maxCount, params->count, params->shadingRates );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFramebufferAttachmentParameteriv( void *args )
{
    struct glGetFramebufferAttachmentParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFramebufferAttachmentParameteriv) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glGetFramebufferAttachmentParameteriv( params->target, params->attachment, params->pname, params->params );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFramebufferAttachmentParameterivEXT( void *args )
{
    struct glGetFramebufferAttachmentParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFramebufferAttachmentParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( params->teb );
    funcs->p_glGetFramebufferAttachmentParameterivEXT( params->target, params->attachment, params->pname, params->params );
    pop_default_fbo( params->teb );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFramebufferParameterfvAMD( void *args )
{
    struct glGetFramebufferParameterfvAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFramebufferParameterfvAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFramebufferParameterfvAMD( params->target, params->pname, params->numsamples, params->pixelindex, params->size, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFramebufferParameteriv( void *args )
{
    struct glGetFramebufferParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFramebufferParameteriv) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetFramebufferParameteriv( params->teb, params->target, params->pname, params->params, funcs->p_glGetFramebufferParameteriv );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFramebufferParameterivEXT( void *args )
{
    struct glGetFramebufferParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFramebufferParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetFramebufferParameterivEXT( params->teb, params->framebuffer, params->pname, params->params, funcs->p_glGetFramebufferParameterivEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetFramebufferParameterivMESA( void *args )
{
    struct glGetFramebufferParameterivMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetFramebufferParameterivMESA) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetFramebufferParameteriv( params->teb, params->target, params->pname, params->params, funcs->p_glGetFramebufferParameterivMESA );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetGraphicsResetStatus( void *args )
{
    struct glGetGraphicsResetStatus_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetGraphicsResetStatus) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetGraphicsResetStatus();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetGraphicsResetStatusARB( void *args )
{
    struct glGetGraphicsResetStatusARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetGraphicsResetStatusARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetGraphicsResetStatusARB();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetHandleARB( void *args )
{
    struct glGetHandleARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetHandleARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetHandleARB( params->pname );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetHistogram( void *args )
{
    struct glGetHistogram_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetHistogram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetHistogram( params->target, params->reset, params->format, params->type, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetHistogramEXT( void *args )
{
    struct glGetHistogramEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetHistogramEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetHistogramEXT( params->target, params->reset, params->format, params->type, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetHistogramParameterfv( void *args )
{
    struct glGetHistogramParameterfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetHistogramParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetHistogramParameterfv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetHistogramParameterfvEXT( void *args )
{
    struct glGetHistogramParameterfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetHistogramParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetHistogramParameterfvEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetHistogramParameteriv( void *args )
{
    struct glGetHistogramParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetHistogramParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetHistogramParameteriv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetHistogramParameterivEXT( void *args )
{
    struct glGetHistogramParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetHistogramParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetHistogramParameterivEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetHistogramParameterxvOES( void *args )
{
    struct glGetHistogramParameterxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetHistogramParameterxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetHistogramParameterxvOES( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetImageHandleARB( void *args )
{
    struct glGetImageHandleARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetImageHandleARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetImageHandleARB( params->texture, params->level, params->layered, params->layer, params->format );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetImageHandleNV( void *args )
{
    struct glGetImageHandleNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetImageHandleNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetImageHandleNV( params->texture, params->level, params->layered, params->layer, params->format );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetImageTransformParameterfvHP( void *args )
{
    struct glGetImageTransformParameterfvHP_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetImageTransformParameterfvHP) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetImageTransformParameterfvHP( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetImageTransformParameterivHP( void *args )
{
    struct glGetImageTransformParameterivHP_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetImageTransformParameterivHP) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetImageTransformParameterivHP( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetInfoLogARB( void *args )
{
    struct glGetInfoLogARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetInfoLogARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetInfoLogARB( params->obj, params->maxLength, params->length, params->infoLog );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetInstrumentsSGIX( void *args )
{
    struct glGetInstrumentsSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetInstrumentsSGIX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetInstrumentsSGIX();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetInteger64i_v( void *args )
{
    struct glGetInteger64i_v_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetInteger64i_v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetInteger64i_v( params->target, params->index, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetInteger64v( void *args )
{
    struct glGetInteger64v_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetInteger64v) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetInteger64v( params->teb, params->pname, params->data, funcs->p_glGetInteger64v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetIntegerIndexedvEXT( void *args )
{
    struct glGetIntegerIndexedvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetIntegerIndexedvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetIntegerIndexedvEXT( params->target, params->index, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetIntegeri_v( void *args )
{
    struct glGetIntegeri_v_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetIntegeri_v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetIntegeri_v( params->target, params->index, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetIntegerui64i_vNV( void *args )
{
    struct glGetIntegerui64i_vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetIntegerui64i_vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetIntegerui64i_vNV( params->value, params->index, params->result );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetIntegerui64vNV( void *args )
{
    struct glGetIntegerui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetIntegerui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetIntegerui64vNV( params->value, params->result );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetInternalformatSampleivNV( void *args )
{
    struct glGetInternalformatSampleivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetInternalformatSampleivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetInternalformatSampleivNV( params->target, params->internalformat, params->samples, params->pname, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetInternalformati64v( void *args )
{
    struct glGetInternalformati64v_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetInternalformati64v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetInternalformati64v( params->target, params->internalformat, params->pname, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetInternalformativ( void *args )
{
    struct glGetInternalformativ_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetInternalformativ) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetInternalformativ( params->target, params->internalformat, params->pname, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetInvariantBooleanvEXT( void *args )
{
    struct glGetInvariantBooleanvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetInvariantBooleanvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetInvariantBooleanvEXT( params->id, params->value, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetInvariantFloatvEXT( void *args )
{
    struct glGetInvariantFloatvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetInvariantFloatvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetInvariantFloatvEXT( params->id, params->value, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetInvariantIntegervEXT( void *args )
{
    struct glGetInvariantIntegervEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetInvariantIntegervEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetInvariantIntegervEXT( params->id, params->value, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetLightxOES( void *args )
{
    struct glGetLightxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetLightxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetLightxOES( params->light, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetLightxv( void *args )
{
    struct glGetLightxv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetLightxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetLightxv( params->light, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetListParameterfvSGIX( void *args )
{
    struct glGetListParameterfvSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetListParameterfvSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetListParameterfvSGIX( params->list, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetListParameterivSGIX( void *args )
{
    struct glGetListParameterivSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetListParameterivSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetListParameterivSGIX( params->list, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetLocalConstantBooleanvEXT( void *args )
{
    struct glGetLocalConstantBooleanvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetLocalConstantBooleanvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetLocalConstantBooleanvEXT( params->id, params->value, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetLocalConstantFloatvEXT( void *args )
{
    struct glGetLocalConstantFloatvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetLocalConstantFloatvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetLocalConstantFloatvEXT( params->id, params->value, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetLocalConstantIntegervEXT( void *args )
{
    struct glGetLocalConstantIntegervEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetLocalConstantIntegervEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetLocalConstantIntegervEXT( params->id, params->value, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMapAttribParameterfvNV( void *args )
{
    struct glGetMapAttribParameterfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMapAttribParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapAttribParameterfvNV( params->target, params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMapAttribParameterivNV( void *args )
{
    struct glGetMapAttribParameterivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMapAttribParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapAttribParameterivNV( params->target, params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMapControlPointsNV( void *args )
{
    struct glGetMapControlPointsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMapControlPointsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapControlPointsNV( params->target, params->index, params->type, params->ustride, params->vstride, params->packed, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMapParameterfvNV( void *args )
{
    struct glGetMapParameterfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMapParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapParameterfvNV( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMapParameterivNV( void *args )
{
    struct glGetMapParameterivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMapParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapParameterivNV( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMapxvOES( void *args )
{
    struct glGetMapxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMapxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapxvOES( params->target, params->query, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMaterialxOES( void *args )
{
    struct glGetMaterialxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMaterialxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMaterialxOES( params->face, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMaterialxv( void *args )
{
    struct glGetMaterialxv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMaterialxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMaterialxv( params->face, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMemoryObjectDetachedResourcesuivNV( void *args )
{
    struct glGetMemoryObjectDetachedResourcesuivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMemoryObjectDetachedResourcesuivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMemoryObjectDetachedResourcesuivNV( params->memory, params->pname, params->first, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMemoryObjectParameterivEXT( void *args )
{
    struct glGetMemoryObjectParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMemoryObjectParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMemoryObjectParameterivEXT( params->memoryObject, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMinmax( void *args )
{
    struct glGetMinmax_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMinmax) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMinmax( params->target, params->reset, params->format, params->type, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMinmaxEXT( void *args )
{
    struct glGetMinmaxEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMinmaxEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMinmaxEXT( params->target, params->reset, params->format, params->type, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMinmaxParameterfv( void *args )
{
    struct glGetMinmaxParameterfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMinmaxParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMinmaxParameterfv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMinmaxParameterfvEXT( void *args )
{
    struct glGetMinmaxParameterfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMinmaxParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMinmaxParameterfvEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMinmaxParameteriv( void *args )
{
    struct glGetMinmaxParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMinmaxParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMinmaxParameteriv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMinmaxParameterivEXT( void *args )
{
    struct glGetMinmaxParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMinmaxParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMinmaxParameterivEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMultiTexEnvfvEXT( void *args )
{
    struct glGetMultiTexEnvfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMultiTexEnvfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexEnvfvEXT( params->texunit, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMultiTexEnvivEXT( void *args )
{
    struct glGetMultiTexEnvivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMultiTexEnvivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexEnvivEXT( params->texunit, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMultiTexGendvEXT( void *args )
{
    struct glGetMultiTexGendvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMultiTexGendvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexGendvEXT( params->texunit, params->coord, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMultiTexGenfvEXT( void *args )
{
    struct glGetMultiTexGenfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMultiTexGenfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexGenfvEXT( params->texunit, params->coord, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMultiTexGenivEXT( void *args )
{
    struct glGetMultiTexGenivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMultiTexGenivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexGenivEXT( params->texunit, params->coord, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMultiTexImageEXT( void *args )
{
    struct glGetMultiTexImageEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMultiTexImageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexImageEXT( params->texunit, params->target, params->level, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMultiTexLevelParameterfvEXT( void *args )
{
    struct glGetMultiTexLevelParameterfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMultiTexLevelParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexLevelParameterfvEXT( params->texunit, params->target, params->level, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMultiTexLevelParameterivEXT( void *args )
{
    struct glGetMultiTexLevelParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMultiTexLevelParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexLevelParameterivEXT( params->texunit, params->target, params->level, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMultiTexParameterIivEXT( void *args )
{
    struct glGetMultiTexParameterIivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMultiTexParameterIivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexParameterIivEXT( params->texunit, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMultiTexParameterIuivEXT( void *args )
{
    struct glGetMultiTexParameterIuivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMultiTexParameterIuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexParameterIuivEXT( params->texunit, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMultiTexParameterfvEXT( void *args )
{
    struct glGetMultiTexParameterfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMultiTexParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexParameterfvEXT( params->texunit, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMultiTexParameterivEXT( void *args )
{
    struct glGetMultiTexParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMultiTexParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexParameterivEXT( params->texunit, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMultisamplefv( void *args )
{
    struct glGetMultisamplefv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMultisamplefv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultisamplefv( params->pname, params->index, params->val );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetMultisamplefvNV( void *args )
{
    struct glGetMultisamplefvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetMultisamplefvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultisamplefvNV( params->pname, params->index, params->val );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedBufferParameteri64v( void *args )
{
    struct glGetNamedBufferParameteri64v_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedBufferParameteri64v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedBufferParameteri64v( params->buffer, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedBufferParameteriv( void *args )
{
    struct glGetNamedBufferParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedBufferParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedBufferParameteriv( params->buffer, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedBufferParameterivEXT( void *args )
{
    struct glGetNamedBufferParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedBufferParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedBufferParameterivEXT( params->buffer, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedBufferParameterui64vNV( void *args )
{
    struct glGetNamedBufferParameterui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedBufferParameterui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedBufferParameterui64vNV( params->buffer, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedBufferPointerv( void *args )
{
    struct glGetNamedBufferPointerv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedBufferPointerv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedBufferPointerv( params->buffer, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedBufferPointervEXT( void *args )
{
    struct glGetNamedBufferPointervEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedBufferPointervEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedBufferPointervEXT( params->buffer, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedBufferSubData( void *args )
{
    struct glGetNamedBufferSubData_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedBufferSubData( params->buffer, params->offset, params->size, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedBufferSubDataEXT( void *args )
{
    struct glGetNamedBufferSubDataEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedBufferSubDataEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedBufferSubDataEXT( params->buffer, params->offset, params->size, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedFramebufferAttachmentParameteriv( void *args )
{
    struct glGetNamedFramebufferAttachmentParameteriv_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedFramebufferAttachmentParameteriv) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glGetNamedFramebufferAttachmentParameteriv( framebuffer, params->attachment, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedFramebufferAttachmentParameterivEXT( void *args )
{
    struct glGetNamedFramebufferAttachmentParameterivEXT_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedFramebufferAttachmentParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glGetNamedFramebufferAttachmentParameterivEXT( framebuffer, params->attachment, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedFramebufferParameterfvAMD( void *args )
{
    struct glGetNamedFramebufferParameterfvAMD_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedFramebufferParameterfvAMD) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glGetNamedFramebufferParameterfvAMD( framebuffer, params->pname, params->numsamples, params->pixelindex, params->size, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedFramebufferParameteriv( void *args )
{
    struct glGetNamedFramebufferParameteriv_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedFramebufferParameteriv) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glGetNamedFramebufferParameteriv( framebuffer, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedFramebufferParameterivEXT( void *args )
{
    struct glGetNamedFramebufferParameterivEXT_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedFramebufferParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glGetNamedFramebufferParameterivEXT( framebuffer, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedProgramLocalParameterIivEXT( void *args )
{
    struct glGetNamedProgramLocalParameterIivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedProgramLocalParameterIivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedProgramLocalParameterIivEXT( params->program, params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedProgramLocalParameterIuivEXT( void *args )
{
    struct glGetNamedProgramLocalParameterIuivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedProgramLocalParameterIuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedProgramLocalParameterIuivEXT( params->program, params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedProgramLocalParameterdvEXT( void *args )
{
    struct glGetNamedProgramLocalParameterdvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedProgramLocalParameterdvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedProgramLocalParameterdvEXT( params->program, params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedProgramLocalParameterfvEXT( void *args )
{
    struct glGetNamedProgramLocalParameterfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedProgramLocalParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedProgramLocalParameterfvEXT( params->program, params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedProgramStringEXT( void *args )
{
    struct glGetNamedProgramStringEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedProgramStringEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedProgramStringEXT( params->program, params->target, params->pname, params->string );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedProgramivEXT( void *args )
{
    struct glGetNamedProgramivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedProgramivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedProgramivEXT( params->program, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedRenderbufferParameteriv( void *args )
{
    struct glGetNamedRenderbufferParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedRenderbufferParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedRenderbufferParameteriv( params->renderbuffer, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedRenderbufferParameterivEXT( void *args )
{
    struct glGetNamedRenderbufferParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedRenderbufferParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedRenderbufferParameterivEXT( params->renderbuffer, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedStringARB( void *args )
{
    struct glGetNamedStringARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedStringARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedStringARB( params->namelen, params->name, params->bufSize, params->stringlen, params->string );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNamedStringivARB( void *args )
{
    struct glGetNamedStringivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNamedStringivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedStringivARB( params->namelen, params->name, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetNextPerfQueryIdINTEL( void *args )
{
    struct glGetNextPerfQueryIdINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetNextPerfQueryIdINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNextPerfQueryIdINTEL( params->queryId, params->nextQueryId );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetObjectBufferfvATI( void *args )
{
    struct glGetObjectBufferfvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetObjectBufferfvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetObjectBufferfvATI( params->buffer, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetObjectBufferivATI( void *args )
{
    struct glGetObjectBufferivATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetObjectBufferivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetObjectBufferivATI( params->buffer, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetObjectLabel( void *args )
{
    struct glGetObjectLabel_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetObjectLabel) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetObjectLabel( params->identifier, params->name, params->bufSize, params->length, params->label );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetObjectLabelEXT( void *args )
{
    struct glGetObjectLabelEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetObjectLabelEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetObjectLabelEXT( params->type, params->object, params->bufSize, params->length, params->label );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetObjectParameterfvARB( void *args )
{
    struct glGetObjectParameterfvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetObjectParameterfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetObjectParameterfvARB( params->obj, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetObjectParameterivAPPLE( void *args )
{
    struct glGetObjectParameterivAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetObjectParameterivAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetObjectParameterivAPPLE( params->objectType, params->name, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetObjectParameterivARB( void *args )
{
    struct glGetObjectParameterivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetObjectParameterivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetObjectParameterivARB( params->obj, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetObjectPtrLabel( void *args )
{
    struct glGetObjectPtrLabel_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetObjectPtrLabel) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetObjectPtrLabel( params->ptr, params->bufSize, params->length, params->label );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetOcclusionQueryivNV( void *args )
{
    struct glGetOcclusionQueryivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetOcclusionQueryivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetOcclusionQueryivNV( params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetOcclusionQueryuivNV( void *args )
{
    struct glGetOcclusionQueryuivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetOcclusionQueryuivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetOcclusionQueryuivNV( params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPathColorGenfvNV( void *args )
{
    struct glGetPathColorGenfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPathColorGenfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathColorGenfvNV( params->color, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPathColorGenivNV( void *args )
{
    struct glGetPathColorGenivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPathColorGenivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathColorGenivNV( params->color, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPathCommandsNV( void *args )
{
    struct glGetPathCommandsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPathCommandsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathCommandsNV( params->path, params->commands );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPathCoordsNV( void *args )
{
    struct glGetPathCoordsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPathCoordsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathCoordsNV( params->path, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPathDashArrayNV( void *args )
{
    struct glGetPathDashArrayNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPathDashArrayNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathDashArrayNV( params->path, params->dashArray );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPathLengthNV( void *args )
{
    struct glGetPathLengthNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPathLengthNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetPathLengthNV( params->path, params->startSegment, params->numSegments );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPathMetricRangeNV( void *args )
{
    struct glGetPathMetricRangeNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPathMetricRangeNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathMetricRangeNV( params->metricQueryMask, params->firstPathName, params->numPaths, params->stride, params->metrics );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPathMetricsNV( void *args )
{
    struct glGetPathMetricsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPathMetricsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathMetricsNV( params->metricQueryMask, params->numPaths, params->pathNameType, params->paths, params->pathBase, params->stride, params->metrics );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPathParameterfvNV( void *args )
{
    struct glGetPathParameterfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPathParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathParameterfvNV( params->path, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPathParameterivNV( void *args )
{
    struct glGetPathParameterivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPathParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathParameterivNV( params->path, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPathSpacingNV( void *args )
{
    struct glGetPathSpacingNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPathSpacingNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathSpacingNV( params->pathListMode, params->numPaths, params->pathNameType, params->paths, params->pathBase, params->advanceScale, params->kerningScale, params->transformType, params->returnedSpacing );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPathTexGenfvNV( void *args )
{
    struct glGetPathTexGenfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPathTexGenfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathTexGenfvNV( params->texCoordSet, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPathTexGenivNV( void *args )
{
    struct glGetPathTexGenivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPathTexGenivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathTexGenivNV( params->texCoordSet, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPerfCounterInfoINTEL( void *args )
{
    struct glGetPerfCounterInfoINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPerfCounterInfoINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfCounterInfoINTEL( params->queryId, params->counterId, params->counterNameLength, params->counterName, params->counterDescLength, params->counterDesc, params->counterOffset, params->counterDataSize, params->counterTypeEnum, params->counterDataTypeEnum, params->rawCounterMaxValue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPerfMonitorCounterDataAMD( void *args )
{
    struct glGetPerfMonitorCounterDataAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPerfMonitorCounterDataAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfMonitorCounterDataAMD( params->monitor, params->pname, params->dataSize, params->data, params->bytesWritten );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPerfMonitorCounterInfoAMD( void *args )
{
    struct glGetPerfMonitorCounterInfoAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPerfMonitorCounterInfoAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfMonitorCounterInfoAMD( params->group, params->counter, params->pname, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPerfMonitorCounterStringAMD( void *args )
{
    struct glGetPerfMonitorCounterStringAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPerfMonitorCounterStringAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfMonitorCounterStringAMD( params->group, params->counter, params->bufSize, params->length, params->counterString );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPerfMonitorCountersAMD( void *args )
{
    struct glGetPerfMonitorCountersAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPerfMonitorCountersAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfMonitorCountersAMD( params->group, params->numCounters, params->maxActiveCounters, params->counterSize, params->counters );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPerfMonitorGroupStringAMD( void *args )
{
    struct glGetPerfMonitorGroupStringAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPerfMonitorGroupStringAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfMonitorGroupStringAMD( params->group, params->bufSize, params->length, params->groupString );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPerfMonitorGroupsAMD( void *args )
{
    struct glGetPerfMonitorGroupsAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPerfMonitorGroupsAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfMonitorGroupsAMD( params->numGroups, params->groupsSize, params->groups );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPerfQueryDataINTEL( void *args )
{
    struct glGetPerfQueryDataINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPerfQueryDataINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfQueryDataINTEL( params->queryHandle, params->flags, params->dataSize, params->data, params->bytesWritten );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPerfQueryIdByNameINTEL( void *args )
{
    struct glGetPerfQueryIdByNameINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPerfQueryIdByNameINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfQueryIdByNameINTEL( params->queryName, params->queryId );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPerfQueryInfoINTEL( void *args )
{
    struct glGetPerfQueryInfoINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPerfQueryInfoINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfQueryInfoINTEL( params->queryId, params->queryNameLength, params->queryName, params->dataSize, params->noCounters, params->noInstances, params->capsMask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPixelMapxv( void *args )
{
    struct glGetPixelMapxv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPixelMapxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPixelMapxv( params->map, params->size, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPixelTexGenParameterfvSGIS( void *args )
{
    struct glGetPixelTexGenParameterfvSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPixelTexGenParameterfvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPixelTexGenParameterfvSGIS( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPixelTexGenParameterivSGIS( void *args )
{
    struct glGetPixelTexGenParameterivSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPixelTexGenParameterivSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPixelTexGenParameterivSGIS( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPixelTransformParameterfvEXT( void *args )
{
    struct glGetPixelTransformParameterfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPixelTransformParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPixelTransformParameterfvEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPixelTransformParameterivEXT( void *args )
{
    struct glGetPixelTransformParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPixelTransformParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPixelTransformParameterivEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPointerIndexedvEXT( void *args )
{
    struct glGetPointerIndexedvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPointerIndexedvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPointerIndexedvEXT( params->target, params->index, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPointeri_vEXT( void *args )
{
    struct glGetPointeri_vEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPointeri_vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPointeri_vEXT( params->pname, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetPointervEXT( void *args )
{
    struct glGetPointervEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetPointervEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPointervEXT( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramBinary( void *args )
{
    struct glGetProgramBinary_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramBinary) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramBinary( params->program, params->bufSize, params->length, params->binaryFormat, params->binary );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramEnvParameterIivNV( void *args )
{
    struct glGetProgramEnvParameterIivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramEnvParameterIivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramEnvParameterIivNV( params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramEnvParameterIuivNV( void *args )
{
    struct glGetProgramEnvParameterIuivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramEnvParameterIuivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramEnvParameterIuivNV( params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramEnvParameterdvARB( void *args )
{
    struct glGetProgramEnvParameterdvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramEnvParameterdvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramEnvParameterdvARB( params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramEnvParameterfvARB( void *args )
{
    struct glGetProgramEnvParameterfvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramEnvParameterfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramEnvParameterfvARB( params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramInfoLog( void *args )
{
    struct glGetProgramInfoLog_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramInfoLog) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramInfoLog( params->program, params->bufSize, params->length, params->infoLog );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramInterfaceiv( void *args )
{
    struct glGetProgramInterfaceiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramInterfaceiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramInterfaceiv( params->program, params->programInterface, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramLocalParameterIivNV( void *args )
{
    struct glGetProgramLocalParameterIivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramLocalParameterIivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramLocalParameterIivNV( params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramLocalParameterIuivNV( void *args )
{
    struct glGetProgramLocalParameterIuivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramLocalParameterIuivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramLocalParameterIuivNV( params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramLocalParameterdvARB( void *args )
{
    struct glGetProgramLocalParameterdvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramLocalParameterdvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramLocalParameterdvARB( params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramLocalParameterfvARB( void *args )
{
    struct glGetProgramLocalParameterfvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramLocalParameterfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramLocalParameterfvARB( params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramNamedParameterdvNV( void *args )
{
    struct glGetProgramNamedParameterdvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramNamedParameterdvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramNamedParameterdvNV( params->id, params->len, params->name, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramNamedParameterfvNV( void *args )
{
    struct glGetProgramNamedParameterfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramNamedParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramNamedParameterfvNV( params->id, params->len, params->name, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramParameterdvNV( void *args )
{
    struct glGetProgramParameterdvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramParameterdvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramParameterdvNV( params->target, params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramParameterfvNV( void *args )
{
    struct glGetProgramParameterfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramParameterfvNV( params->target, params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramPipelineInfoLog( void *args )
{
    struct glGetProgramPipelineInfoLog_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramPipelineInfoLog) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramPipelineInfoLog( params->pipeline, params->bufSize, params->length, params->infoLog );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramPipelineiv( void *args )
{
    struct glGetProgramPipelineiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramPipelineiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramPipelineiv( params->pipeline, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramResourceIndex( void *args )
{
    struct glGetProgramResourceIndex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramResourceIndex) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetProgramResourceIndex( params->program, params->programInterface, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramResourceLocation( void *args )
{
    struct glGetProgramResourceLocation_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramResourceLocation) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetProgramResourceLocation( params->program, params->programInterface, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramResourceLocationIndex( void *args )
{
    struct glGetProgramResourceLocationIndex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramResourceLocationIndex) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetProgramResourceLocationIndex( params->program, params->programInterface, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramResourceName( void *args )
{
    struct glGetProgramResourceName_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramResourceName) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramResourceName( params->program, params->programInterface, params->index, params->bufSize, params->length, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramResourcefvNV( void *args )
{
    struct glGetProgramResourcefvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramResourcefvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramResourcefvNV( params->program, params->programInterface, params->index, params->propCount, params->props, params->count, params->length, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramResourceiv( void *args )
{
    struct glGetProgramResourceiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramResourceiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramResourceiv( params->program, params->programInterface, params->index, params->propCount, params->props, params->count, params->length, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramStageiv( void *args )
{
    struct glGetProgramStageiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramStageiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramStageiv( params->program, params->shadertype, params->pname, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramStringARB( void *args )
{
    struct glGetProgramStringARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramStringARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramStringARB( params->target, params->pname, params->string );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramStringNV( void *args )
{
    struct glGetProgramStringNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramStringNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramStringNV( params->id, params->pname, params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramSubroutineParameteruivNV( void *args )
{
    struct glGetProgramSubroutineParameteruivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramSubroutineParameteruivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramSubroutineParameteruivNV( params->target, params->index, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramiv( void *args )
{
    struct glGetProgramiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramiv( params->program, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramivARB( void *args )
{
    struct glGetProgramivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramivARB( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetProgramivNV( void *args )
{
    struct glGetProgramivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetProgramivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramivNV( params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetQueryBufferObjecti64v( void *args )
{
    struct glGetQueryBufferObjecti64v_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetQueryBufferObjecti64v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryBufferObjecti64v( params->id, params->buffer, params->pname, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetQueryBufferObjectiv( void *args )
{
    struct glGetQueryBufferObjectiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetQueryBufferObjectiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryBufferObjectiv( params->id, params->buffer, params->pname, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetQueryBufferObjectui64v( void *args )
{
    struct glGetQueryBufferObjectui64v_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetQueryBufferObjectui64v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryBufferObjectui64v( params->id, params->buffer, params->pname, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetQueryBufferObjectuiv( void *args )
{
    struct glGetQueryBufferObjectuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetQueryBufferObjectuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryBufferObjectuiv( params->id, params->buffer, params->pname, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetQueryIndexediv( void *args )
{
    struct glGetQueryIndexediv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetQueryIndexediv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryIndexediv( params->target, params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetQueryObjecti64v( void *args )
{
    struct glGetQueryObjecti64v_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetQueryObjecti64v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryObjecti64v( params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetQueryObjecti64vEXT( void *args )
{
    struct glGetQueryObjecti64vEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetQueryObjecti64vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryObjecti64vEXT( params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetQueryObjectiv( void *args )
{
    struct glGetQueryObjectiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetQueryObjectiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryObjectiv( params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetQueryObjectivARB( void *args )
{
    struct glGetQueryObjectivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetQueryObjectivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryObjectivARB( params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetQueryObjectui64v( void *args )
{
    struct glGetQueryObjectui64v_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetQueryObjectui64v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryObjectui64v( params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetQueryObjectui64vEXT( void *args )
{
    struct glGetQueryObjectui64vEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetQueryObjectui64vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryObjectui64vEXT( params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetQueryObjectuiv( void *args )
{
    struct glGetQueryObjectuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetQueryObjectuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryObjectuiv( params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetQueryObjectuivARB( void *args )
{
    struct glGetQueryObjectuivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetQueryObjectuivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryObjectuivARB( params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetQueryiv( void *args )
{
    struct glGetQueryiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetQueryiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryiv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetQueryivARB( void *args )
{
    struct glGetQueryivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetQueryivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryivARB( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetRenderbufferParameteriv( void *args )
{
    struct glGetRenderbufferParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetRenderbufferParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetRenderbufferParameteriv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetRenderbufferParameterivEXT( void *args )
{
    struct glGetRenderbufferParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetRenderbufferParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetRenderbufferParameterivEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetSamplerParameterIiv( void *args )
{
    struct glGetSamplerParameterIiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetSamplerParameterIiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSamplerParameterIiv( params->sampler, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetSamplerParameterIuiv( void *args )
{
    struct glGetSamplerParameterIuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetSamplerParameterIuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSamplerParameterIuiv( params->sampler, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetSamplerParameterfv( void *args )
{
    struct glGetSamplerParameterfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetSamplerParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSamplerParameterfv( params->sampler, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetSamplerParameteriv( void *args )
{
    struct glGetSamplerParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetSamplerParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSamplerParameteriv( params->sampler, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetSemaphoreParameterivNV( void *args )
{
    struct glGetSemaphoreParameterivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetSemaphoreParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSemaphoreParameterivNV( params->semaphore, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetSemaphoreParameterui64vEXT( void *args )
{
    struct glGetSemaphoreParameterui64vEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetSemaphoreParameterui64vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSemaphoreParameterui64vEXT( params->semaphore, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetSeparableFilter( void *args )
{
    struct glGetSeparableFilter_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetSeparableFilter) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSeparableFilter( params->target, params->format, params->type, params->row, params->column, params->span );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetSeparableFilterEXT( void *args )
{
    struct glGetSeparableFilterEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetSeparableFilterEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSeparableFilterEXT( params->target, params->format, params->type, params->row, params->column, params->span );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetShaderInfoLog( void *args )
{
    struct glGetShaderInfoLog_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetShaderInfoLog) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetShaderInfoLog( params->shader, params->bufSize, params->length, params->infoLog );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetShaderPrecisionFormat( void *args )
{
    struct glGetShaderPrecisionFormat_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetShaderPrecisionFormat) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetShaderPrecisionFormat( params->shadertype, params->precisiontype, params->range, params->precision );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetShaderSource( void *args )
{
    struct glGetShaderSource_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetShaderSource) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetShaderSource( params->shader, params->bufSize, params->length, params->source );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetShaderSourceARB( void *args )
{
    struct glGetShaderSourceARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetShaderSourceARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetShaderSourceARB( params->obj, params->maxLength, params->length, params->source );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetShaderiv( void *args )
{
    struct glGetShaderiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetShaderiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetShaderiv( params->shader, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetShadingRateImagePaletteNV( void *args )
{
    struct glGetShadingRateImagePaletteNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetShadingRateImagePaletteNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetShadingRateImagePaletteNV( params->viewport, params->entry, params->rate );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetShadingRateSampleLocationivNV( void *args )
{
    struct glGetShadingRateSampleLocationivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetShadingRateSampleLocationivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetShadingRateSampleLocationivNV( params->rate, params->samples, params->index, params->location );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetSharpenTexFuncSGIS( void *args )
{
    struct glGetSharpenTexFuncSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetSharpenTexFuncSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSharpenTexFuncSGIS( params->target, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetStageIndexNV( void *args )
{
    struct glGetStageIndexNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetStageIndexNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetStageIndexNV( params->shadertype );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetStringi( void *args )
{
    struct glGetStringi_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetStringi) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetStringi( params->name, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetSubroutineIndex( void *args )
{
    struct glGetSubroutineIndex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetSubroutineIndex) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetSubroutineIndex( params->program, params->shadertype, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetSubroutineUniformLocation( void *args )
{
    struct glGetSubroutineUniformLocation_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetSubroutineUniformLocation) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetSubroutineUniformLocation( params->program, params->shadertype, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetSynciv( void *args )
{
    struct glGetSynciv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetSynciv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSynciv( get_unix_sync( params->sync ), params->pname, params->count, params->length, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTexBumpParameterfvATI( void *args )
{
    struct glGetTexBumpParameterfvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexBumpParameterfvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexBumpParameterfvATI( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTexBumpParameterivATI( void *args )
{
    struct glGetTexBumpParameterivATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexBumpParameterivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexBumpParameterivATI( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTexEnvxv( void *args )
{
    struct glGetTexEnvxv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexEnvxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexEnvxv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTexEnvxvOES( void *args )
{
    struct glGetTexEnvxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexEnvxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexEnvxvOES( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTexFilterFuncSGIS( void *args )
{
    struct glGetTexFilterFuncSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexFilterFuncSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexFilterFuncSGIS( params->target, params->filter, params->weights );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTexGenxvOES( void *args )
{
    struct glGetTexGenxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexGenxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexGenxvOES( params->coord, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTexLevelParameterxvOES( void *args )
{
    struct glGetTexLevelParameterxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexLevelParameterxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexLevelParameterxvOES( params->target, params->level, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTexParameterIiv( void *args )
{
    struct glGetTexParameterIiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexParameterIiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameterIiv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTexParameterIivEXT( void *args )
{
    struct glGetTexParameterIivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexParameterIivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameterIivEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTexParameterIuiv( void *args )
{
    struct glGetTexParameterIuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexParameterIuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameterIuiv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTexParameterIuivEXT( void *args )
{
    struct glGetTexParameterIuivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexParameterIuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameterIuivEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTexParameterPointervAPPLE( void *args )
{
    struct glGetTexParameterPointervAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexParameterPointervAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameterPointervAPPLE( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTexParameterxv( void *args )
{
    struct glGetTexParameterxv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexParameterxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameterxv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTexParameterxvOES( void *args )
{
    struct glGetTexParameterxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTexParameterxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameterxvOES( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureHandleARB( void *args )
{
    struct glGetTextureHandleARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureHandleARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetTextureHandleARB( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureHandleNV( void *args )
{
    struct glGetTextureHandleNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureHandleNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetTextureHandleNV( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureImage( void *args )
{
    struct glGetTextureImage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureImage( params->texture, params->level, params->format, params->type, params->bufSize, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureImageEXT( void *args )
{
    struct glGetTextureImageEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureImageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureImageEXT( params->texture, params->target, params->level, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureLevelParameterfv( void *args )
{
    struct glGetTextureLevelParameterfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureLevelParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureLevelParameterfv( params->texture, params->level, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureLevelParameterfvEXT( void *args )
{
    struct glGetTextureLevelParameterfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureLevelParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureLevelParameterfvEXT( params->texture, params->target, params->level, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureLevelParameteriv( void *args )
{
    struct glGetTextureLevelParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureLevelParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureLevelParameteriv( params->texture, params->level, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureLevelParameterivEXT( void *args )
{
    struct glGetTextureLevelParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureLevelParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureLevelParameterivEXT( params->texture, params->target, params->level, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureParameterIiv( void *args )
{
    struct glGetTextureParameterIiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureParameterIiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureParameterIiv( params->texture, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureParameterIivEXT( void *args )
{
    struct glGetTextureParameterIivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureParameterIivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureParameterIivEXT( params->texture, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureParameterIuiv( void *args )
{
    struct glGetTextureParameterIuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureParameterIuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureParameterIuiv( params->texture, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureParameterIuivEXT( void *args )
{
    struct glGetTextureParameterIuivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureParameterIuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureParameterIuivEXT( params->texture, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureParameterfv( void *args )
{
    struct glGetTextureParameterfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureParameterfv( params->texture, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureParameterfvEXT( void *args )
{
    struct glGetTextureParameterfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureParameterfvEXT( params->texture, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureParameteriv( void *args )
{
    struct glGetTextureParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureParameteriv( params->texture, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureParameterivEXT( void *args )
{
    struct glGetTextureParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureParameterivEXT( params->texture, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureSamplerHandleARB( void *args )
{
    struct glGetTextureSamplerHandleARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureSamplerHandleARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetTextureSamplerHandleARB( params->texture, params->sampler );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureSamplerHandleNV( void *args )
{
    struct glGetTextureSamplerHandleNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureSamplerHandleNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetTextureSamplerHandleNV( params->texture, params->sampler );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTextureSubImage( void *args )
{
    struct glGetTextureSubImage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTextureSubImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureSubImage( params->texture, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->type, params->bufSize, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTrackMatrixivNV( void *args )
{
    struct glGetTrackMatrixivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTrackMatrixivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTrackMatrixivNV( params->target, params->address, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTransformFeedbackVarying( void *args )
{
    struct glGetTransformFeedbackVarying_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTransformFeedbackVarying) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTransformFeedbackVarying( params->program, params->index, params->bufSize, params->length, params->size, params->type, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTransformFeedbackVaryingEXT( void *args )
{
    struct glGetTransformFeedbackVaryingEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTransformFeedbackVaryingEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTransformFeedbackVaryingEXT( params->program, params->index, params->bufSize, params->length, params->size, params->type, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTransformFeedbackVaryingNV( void *args )
{
    struct glGetTransformFeedbackVaryingNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTransformFeedbackVaryingNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTransformFeedbackVaryingNV( params->program, params->index, params->location );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTransformFeedbacki64_v( void *args )
{
    struct glGetTransformFeedbacki64_v_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTransformFeedbacki64_v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTransformFeedbacki64_v( params->xfb, params->pname, params->index, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTransformFeedbacki_v( void *args )
{
    struct glGetTransformFeedbacki_v_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTransformFeedbacki_v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTransformFeedbacki_v( params->xfb, params->pname, params->index, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetTransformFeedbackiv( void *args )
{
    struct glGetTransformFeedbackiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetTransformFeedbackiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTransformFeedbackiv( params->xfb, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformBlockIndex( void *args )
{
    struct glGetUniformBlockIndex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformBlockIndex) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetUniformBlockIndex( params->program, params->uniformBlockName );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformBufferSizeEXT( void *args )
{
    struct glGetUniformBufferSizeEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformBufferSizeEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetUniformBufferSizeEXT( params->program, params->location );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformIndices( void *args )
{
    struct glGetUniformIndices_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformIndices) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformIndices( params->program, params->uniformCount, params->uniformNames, params->uniformIndices );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformLocation( void *args )
{
    struct glGetUniformLocation_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformLocation) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetUniformLocation( params->program, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformLocationARB( void *args )
{
    struct glGetUniformLocationARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformLocationARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetUniformLocationARB( params->programObj, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformOffsetEXT( void *args )
{
    struct glGetUniformOffsetEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetUniformOffsetEXT( params->program, params->location );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformSubroutineuiv( void *args )
{
    struct glGetUniformSubroutineuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformSubroutineuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformSubroutineuiv( params->shadertype, params->location, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformdv( void *args )
{
    struct glGetUniformdv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformdv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformdv( params->program, params->location, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformfv( void *args )
{
    struct glGetUniformfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformfv( params->program, params->location, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformfvARB( void *args )
{
    struct glGetUniformfvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformfvARB( params->programObj, params->location, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformi64vARB( void *args )
{
    struct glGetUniformi64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformi64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformi64vARB( params->program, params->location, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformi64vNV( void *args )
{
    struct glGetUniformi64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformi64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformi64vNV( params->program, params->location, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformiv( void *args )
{
    struct glGetUniformiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformiv( params->program, params->location, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformivARB( void *args )
{
    struct glGetUniformivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformivARB( params->programObj, params->location, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformui64vARB( void *args )
{
    struct glGetUniformui64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformui64vARB( params->program, params->location, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformui64vNV( void *args )
{
    struct glGetUniformui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformui64vNV( params->program, params->location, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformuiv( void *args )
{
    struct glGetUniformuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformuiv( params->program, params->location, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUniformuivEXT( void *args )
{
    struct glGetUniformuivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUniformuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformuivEXT( params->program, params->location, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUnsignedBytei_vEXT( void *args )
{
    struct glGetUnsignedBytei_vEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUnsignedBytei_vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUnsignedBytei_vEXT( params->target, params->index, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetUnsignedBytevEXT( void *args )
{
    struct glGetUnsignedBytevEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetUnsignedBytevEXT) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetUnsignedBytevEXT( params->teb, params->pname, params->data, funcs->p_glGetUnsignedBytevEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVariantArrayObjectfvATI( void *args )
{
    struct glGetVariantArrayObjectfvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVariantArrayObjectfvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVariantArrayObjectfvATI( params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVariantArrayObjectivATI( void *args )
{
    struct glGetVariantArrayObjectivATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVariantArrayObjectivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVariantArrayObjectivATI( params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVariantBooleanvEXT( void *args )
{
    struct glGetVariantBooleanvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVariantBooleanvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVariantBooleanvEXT( params->id, params->value, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVariantFloatvEXT( void *args )
{
    struct glGetVariantFloatvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVariantFloatvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVariantFloatvEXT( params->id, params->value, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVariantIntegervEXT( void *args )
{
    struct glGetVariantIntegervEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVariantIntegervEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVariantIntegervEXT( params->id, params->value, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVariantPointervEXT( void *args )
{
    struct glGetVariantPointervEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVariantPointervEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVariantPointervEXT( params->id, params->value, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVaryingLocationNV( void *args )
{
    struct glGetVaryingLocationNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVaryingLocationNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetVaryingLocationNV( params->program, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexArrayIndexed64iv( void *args )
{
    struct glGetVertexArrayIndexed64iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexArrayIndexed64iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexArrayIndexed64iv( params->vaobj, params->index, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexArrayIndexediv( void *args )
{
    struct glGetVertexArrayIndexediv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexArrayIndexediv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexArrayIndexediv( params->vaobj, params->index, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexArrayIntegeri_vEXT( void *args )
{
    struct glGetVertexArrayIntegeri_vEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexArrayIntegeri_vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexArrayIntegeri_vEXT( params->vaobj, params->index, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexArrayIntegervEXT( void *args )
{
    struct glGetVertexArrayIntegervEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexArrayIntegervEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexArrayIntegervEXT( params->vaobj, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexArrayPointeri_vEXT( void *args )
{
    struct glGetVertexArrayPointeri_vEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexArrayPointeri_vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexArrayPointeri_vEXT( params->vaobj, params->index, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexArrayPointervEXT( void *args )
{
    struct glGetVertexArrayPointervEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexArrayPointervEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexArrayPointervEXT( params->vaobj, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexArrayiv( void *args )
{
    struct glGetVertexArrayiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexArrayiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexArrayiv( params->vaobj, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribArrayObjectfvATI( void *args )
{
    struct glGetVertexAttribArrayObjectfvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribArrayObjectfvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribArrayObjectfvATI( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribArrayObjectivATI( void *args )
{
    struct glGetVertexAttribArrayObjectivATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribArrayObjectivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribArrayObjectivATI( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribIiv( void *args )
{
    struct glGetVertexAttribIiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribIiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribIiv( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribIivEXT( void *args )
{
    struct glGetVertexAttribIivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribIivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribIivEXT( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribIuiv( void *args )
{
    struct glGetVertexAttribIuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribIuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribIuiv( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribIuivEXT( void *args )
{
    struct glGetVertexAttribIuivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribIuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribIuivEXT( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribLdv( void *args )
{
    struct glGetVertexAttribLdv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribLdv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribLdv( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribLdvEXT( void *args )
{
    struct glGetVertexAttribLdvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribLdvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribLdvEXT( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribLi64vNV( void *args )
{
    struct glGetVertexAttribLi64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribLi64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribLi64vNV( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribLui64vARB( void *args )
{
    struct glGetVertexAttribLui64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribLui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribLui64vARB( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribLui64vNV( void *args )
{
    struct glGetVertexAttribLui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribLui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribLui64vNV( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribPointerv( void *args )
{
    struct glGetVertexAttribPointerv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribPointerv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribPointerv( params->index, params->pname, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribPointervARB( void *args )
{
    struct glGetVertexAttribPointervARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribPointervARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribPointervARB( params->index, params->pname, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribPointervNV( void *args )
{
    struct glGetVertexAttribPointervNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribPointervNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribPointervNV( params->index, params->pname, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribdv( void *args )
{
    struct glGetVertexAttribdv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribdv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribdv( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribdvARB( void *args )
{
    struct glGetVertexAttribdvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribdvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribdvARB( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribdvNV( void *args )
{
    struct glGetVertexAttribdvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribdvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribdvNV( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribfv( void *args )
{
    struct glGetVertexAttribfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribfv( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribfvARB( void *args )
{
    struct glGetVertexAttribfvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribfvARB( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribfvNV( void *args )
{
    struct glGetVertexAttribfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribfvNV( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribiv( void *args )
{
    struct glGetVertexAttribiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribiv( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribivARB( void *args )
{
    struct glGetVertexAttribivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribivARB( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVertexAttribivNV( void *args )
{
    struct glGetVertexAttribivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVertexAttribivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribivNV( params->index, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVideoCaptureStreamdvNV( void *args )
{
    struct glGetVideoCaptureStreamdvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVideoCaptureStreamdvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVideoCaptureStreamdvNV( params->video_capture_slot, params->stream, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVideoCaptureStreamfvNV( void *args )
{
    struct glGetVideoCaptureStreamfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVideoCaptureStreamfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVideoCaptureStreamfvNV( params->video_capture_slot, params->stream, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVideoCaptureStreamivNV( void *args )
{
    struct glGetVideoCaptureStreamivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVideoCaptureStreamivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVideoCaptureStreamivNV( params->video_capture_slot, params->stream, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVideoCaptureivNV( void *args )
{
    struct glGetVideoCaptureivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVideoCaptureivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVideoCaptureivNV( params->video_capture_slot, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVideoi64vNV( void *args )
{
    struct glGetVideoi64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVideoi64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVideoi64vNV( params->video_slot, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVideoivNV( void *args )
{
    struct glGetVideoivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVideoivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVideoivNV( params->video_slot, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVideoui64vNV( void *args )
{
    struct glGetVideoui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVideoui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVideoui64vNV( params->video_slot, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVideouivNV( void *args )
{
    struct glGetVideouivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVideouivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVideouivNV( params->video_slot, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetVkProcAddrNV( void *args )
{
    struct glGetVkProcAddrNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetVkProcAddrNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetVkProcAddrNV( params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnColorTable( void *args )
{
    struct glGetnColorTable_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnColorTable) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnColorTable( params->target, params->format, params->type, params->bufSize, params->table );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnColorTableARB( void *args )
{
    struct glGetnColorTableARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnColorTableARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnColorTableARB( params->target, params->format, params->type, params->bufSize, params->table );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnCompressedTexImage( void *args )
{
    struct glGetnCompressedTexImage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnCompressedTexImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnCompressedTexImage( params->target, params->lod, params->bufSize, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnCompressedTexImageARB( void *args )
{
    struct glGetnCompressedTexImageARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnCompressedTexImageARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnCompressedTexImageARB( params->target, params->lod, params->bufSize, params->img );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnConvolutionFilter( void *args )
{
    struct glGetnConvolutionFilter_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnConvolutionFilter) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnConvolutionFilter( params->target, params->format, params->type, params->bufSize, params->image );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnConvolutionFilterARB( void *args )
{
    struct glGetnConvolutionFilterARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnConvolutionFilterARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnConvolutionFilterARB( params->target, params->format, params->type, params->bufSize, params->image );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnHistogram( void *args )
{
    struct glGetnHistogram_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnHistogram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnHistogram( params->target, params->reset, params->format, params->type, params->bufSize, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnHistogramARB( void *args )
{
    struct glGetnHistogramARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnHistogramARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnHistogramARB( params->target, params->reset, params->format, params->type, params->bufSize, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnMapdv( void *args )
{
    struct glGetnMapdv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnMapdv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnMapdv( params->target, params->query, params->bufSize, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnMapdvARB( void *args )
{
    struct glGetnMapdvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnMapdvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnMapdvARB( params->target, params->query, params->bufSize, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnMapfv( void *args )
{
    struct glGetnMapfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnMapfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnMapfv( params->target, params->query, params->bufSize, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnMapfvARB( void *args )
{
    struct glGetnMapfvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnMapfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnMapfvARB( params->target, params->query, params->bufSize, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnMapiv( void *args )
{
    struct glGetnMapiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnMapiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnMapiv( params->target, params->query, params->bufSize, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnMapivARB( void *args )
{
    struct glGetnMapivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnMapivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnMapivARB( params->target, params->query, params->bufSize, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnMinmax( void *args )
{
    struct glGetnMinmax_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnMinmax) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnMinmax( params->target, params->reset, params->format, params->type, params->bufSize, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnMinmaxARB( void *args )
{
    struct glGetnMinmaxARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnMinmaxARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnMinmaxARB( params->target, params->reset, params->format, params->type, params->bufSize, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnPixelMapfv( void *args )
{
    struct glGetnPixelMapfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnPixelMapfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnPixelMapfv( params->map, params->bufSize, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnPixelMapfvARB( void *args )
{
    struct glGetnPixelMapfvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnPixelMapfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnPixelMapfvARB( params->map, params->bufSize, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnPixelMapuiv( void *args )
{
    struct glGetnPixelMapuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnPixelMapuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnPixelMapuiv( params->map, params->bufSize, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnPixelMapuivARB( void *args )
{
    struct glGetnPixelMapuivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnPixelMapuivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnPixelMapuivARB( params->map, params->bufSize, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnPixelMapusv( void *args )
{
    struct glGetnPixelMapusv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnPixelMapusv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnPixelMapusv( params->map, params->bufSize, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnPixelMapusvARB( void *args )
{
    struct glGetnPixelMapusvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnPixelMapusvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnPixelMapusvARB( params->map, params->bufSize, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnPolygonStipple( void *args )
{
    struct glGetnPolygonStipple_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnPolygonStipple) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnPolygonStipple( params->bufSize, params->pattern );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnPolygonStippleARB( void *args )
{
    struct glGetnPolygonStippleARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnPolygonStippleARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnPolygonStippleARB( params->bufSize, params->pattern );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnSeparableFilter( void *args )
{
    struct glGetnSeparableFilter_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnSeparableFilter) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnSeparableFilter( params->target, params->format, params->type, params->rowBufSize, params->row, params->columnBufSize, params->column, params->span );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnSeparableFilterARB( void *args )
{
    struct glGetnSeparableFilterARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnSeparableFilterARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnSeparableFilterARB( params->target, params->format, params->type, params->rowBufSize, params->row, params->columnBufSize, params->column, params->span );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnTexImage( void *args )
{
    struct glGetnTexImage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnTexImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnTexImage( params->target, params->level, params->format, params->type, params->bufSize, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnTexImageARB( void *args )
{
    struct glGetnTexImageARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnTexImageARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnTexImageARB( params->target, params->level, params->format, params->type, params->bufSize, params->img );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnUniformdv( void *args )
{
    struct glGetnUniformdv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnUniformdv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformdv( params->program, params->location, params->bufSize, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnUniformdvARB( void *args )
{
    struct glGetnUniformdvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnUniformdvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformdvARB( params->program, params->location, params->bufSize, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnUniformfv( void *args )
{
    struct glGetnUniformfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnUniformfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformfv( params->program, params->location, params->bufSize, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnUniformfvARB( void *args )
{
    struct glGetnUniformfvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnUniformfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformfvARB( params->program, params->location, params->bufSize, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnUniformi64vARB( void *args )
{
    struct glGetnUniformi64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnUniformi64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformi64vARB( params->program, params->location, params->bufSize, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnUniformiv( void *args )
{
    struct glGetnUniformiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnUniformiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformiv( params->program, params->location, params->bufSize, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnUniformivARB( void *args )
{
    struct glGetnUniformivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnUniformivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformivARB( params->program, params->location, params->bufSize, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnUniformui64vARB( void *args )
{
    struct glGetnUniformui64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnUniformui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformui64vARB( params->program, params->location, params->bufSize, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnUniformuiv( void *args )
{
    struct glGetnUniformuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnUniformuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformuiv( params->program, params->location, params->bufSize, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGetnUniformuivARB( void *args )
{
    struct glGetnUniformuivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGetnUniformuivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformuivARB( params->program, params->location, params->bufSize, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGlobalAlphaFactorbSUN( void *args )
{
    struct glGlobalAlphaFactorbSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGlobalAlphaFactorbSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGlobalAlphaFactorbSUN( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGlobalAlphaFactordSUN( void *args )
{
    struct glGlobalAlphaFactordSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGlobalAlphaFactordSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGlobalAlphaFactordSUN( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGlobalAlphaFactorfSUN( void *args )
{
    struct glGlobalAlphaFactorfSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGlobalAlphaFactorfSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGlobalAlphaFactorfSUN( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGlobalAlphaFactoriSUN( void *args )
{
    struct glGlobalAlphaFactoriSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGlobalAlphaFactoriSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGlobalAlphaFactoriSUN( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGlobalAlphaFactorsSUN( void *args )
{
    struct glGlobalAlphaFactorsSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGlobalAlphaFactorsSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGlobalAlphaFactorsSUN( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGlobalAlphaFactorubSUN( void *args )
{
    struct glGlobalAlphaFactorubSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGlobalAlphaFactorubSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGlobalAlphaFactorubSUN( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGlobalAlphaFactoruiSUN( void *args )
{
    struct glGlobalAlphaFactoruiSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGlobalAlphaFactoruiSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGlobalAlphaFactoruiSUN( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glGlobalAlphaFactorusSUN( void *args )
{
    struct glGlobalAlphaFactorusSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glGlobalAlphaFactorusSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGlobalAlphaFactorusSUN( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glHintPGI( void *args )
{
    struct glHintPGI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glHintPGI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glHintPGI( params->target, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glHistogram( void *args )
{
    struct glHistogram_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glHistogram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glHistogram( params->target, params->width, params->internalformat, params->sink );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glHistogramEXT( void *args )
{
    struct glHistogramEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glHistogramEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glHistogramEXT( params->target, params->width, params->internalformat, params->sink );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIglooInterfaceSGIX( void *args )
{
    struct glIglooInterfaceSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIglooInterfaceSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIglooInterfaceSGIX( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glImageTransformParameterfHP( void *args )
{
    struct glImageTransformParameterfHP_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glImageTransformParameterfHP) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glImageTransformParameterfHP( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glImageTransformParameterfvHP( void *args )
{
    struct glImageTransformParameterfvHP_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glImageTransformParameterfvHP) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glImageTransformParameterfvHP( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glImageTransformParameteriHP( void *args )
{
    struct glImageTransformParameteriHP_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glImageTransformParameteriHP) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glImageTransformParameteriHP( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glImageTransformParameterivHP( void *args )
{
    struct glImageTransformParameterivHP_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glImageTransformParameterivHP) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glImageTransformParameterivHP( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glImportMemoryWin32HandleEXT( void *args )
{
    struct glImportMemoryWin32HandleEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glImportMemoryWin32HandleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glImportMemoryWin32HandleEXT( params->memory, params->size, params->handleType, params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glImportMemoryWin32NameEXT( void *args )
{
    struct glImportMemoryWin32NameEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glImportMemoryWin32NameEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glImportMemoryWin32NameEXT( params->memory, params->size, params->handleType, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glImportSemaphoreWin32HandleEXT( void *args )
{
    struct glImportSemaphoreWin32HandleEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glImportSemaphoreWin32HandleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glImportSemaphoreWin32HandleEXT( params->semaphore, params->handleType, params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glImportSemaphoreWin32NameEXT( void *args )
{
    struct glImportSemaphoreWin32NameEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glImportSemaphoreWin32NameEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glImportSemaphoreWin32NameEXT( params->semaphore, params->handleType, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glImportSyncEXT( void *args )
{
    struct glImportSyncEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glImportSyncEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = wrap_glImportSyncEXT( params->teb, params->external_sync_type, params->external_sync, params->flags, params->ret, funcs->p_glImportSyncEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIndexFormatNV( void *args )
{
    struct glIndexFormatNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexFormatNV( params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIndexFuncEXT( void *args )
{
    struct glIndexFuncEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexFuncEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexFuncEXT( params->func, params->ref );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIndexMaterialEXT( void *args )
{
    struct glIndexMaterialEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexMaterialEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexMaterialEXT( params->face, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIndexPointerEXT( void *args )
{
    struct glIndexPointerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexPointerEXT( params->type, params->stride, params->count, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIndexPointerListIBM( void *args )
{
    struct glIndexPointerListIBM_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexPointerListIBM) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexPointerListIBM( params->type, params->stride, params->pointer, params->ptrstride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIndexxOES( void *args )
{
    struct glIndexxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexxOES( params->component );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIndexxvOES( void *args )
{
    struct glIndexxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIndexxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexxvOES( params->component );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glInsertComponentEXT( void *args )
{
    struct glInsertComponentEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glInsertComponentEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInsertComponentEXT( params->res, params->src, params->num );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glInsertEventMarkerEXT( void *args )
{
    struct glInsertEventMarkerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glInsertEventMarkerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInsertEventMarkerEXT( params->length, params->marker );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glInstrumentsBufferSGIX( void *args )
{
    struct glInstrumentsBufferSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glInstrumentsBufferSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInstrumentsBufferSGIX( params->size, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glInterpolatePathsNV( void *args )
{
    struct glInterpolatePathsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glInterpolatePathsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInterpolatePathsNV( params->resultPath, params->pathA, params->pathB, params->weight );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glInvalidateBufferData( void *args )
{
    struct glInvalidateBufferData_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glInvalidateBufferData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInvalidateBufferData( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glInvalidateBufferSubData( void *args )
{
    struct glInvalidateBufferSubData_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glInvalidateBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInvalidateBufferSubData( params->buffer, params->offset, params->length );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glInvalidateFramebuffer( void *args )
{
    struct glInvalidateFramebuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glInvalidateFramebuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInvalidateFramebuffer( params->target, params->numAttachments, params->attachments );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glInvalidateNamedFramebufferData( void *args )
{
    struct glInvalidateNamedFramebufferData_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glInvalidateNamedFramebufferData) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glInvalidateNamedFramebufferData( framebuffer, params->numAttachments, params->attachments );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glInvalidateNamedFramebufferSubData( void *args )
{
    struct glInvalidateNamedFramebufferSubData_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glInvalidateNamedFramebufferSubData) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glInvalidateNamedFramebufferSubData( framebuffer, params->numAttachments, params->attachments, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glInvalidateSubFramebuffer( void *args )
{
    struct glInvalidateSubFramebuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glInvalidateSubFramebuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInvalidateSubFramebuffer( params->target, params->numAttachments, params->attachments, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glInvalidateTexImage( void *args )
{
    struct glInvalidateTexImage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glInvalidateTexImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInvalidateTexImage( params->texture, params->level );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glInvalidateTexSubImage( void *args )
{
    struct glInvalidateTexSubImage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glInvalidateTexSubImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInvalidateTexSubImage( params->texture, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsAsyncMarkerSGIX( void *args )
{
    struct glIsAsyncMarkerSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsAsyncMarkerSGIX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsAsyncMarkerSGIX( params->marker );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsBuffer( void *args )
{
    struct glIsBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsBuffer) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsBuffer( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsBufferARB( void *args )
{
    struct glIsBufferARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsBufferARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsBufferARB( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsBufferResidentNV( void *args )
{
    struct glIsBufferResidentNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsBufferResidentNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsBufferResidentNV( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsCommandListNV( void *args )
{
    struct glIsCommandListNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsCommandListNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsCommandListNV( params->list );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsEnabledIndexedEXT( void *args )
{
    struct glIsEnabledIndexedEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsEnabledIndexedEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsEnabledIndexedEXT( params->target, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsEnabledi( void *args )
{
    struct glIsEnabledi_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsEnabledi) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsEnabledi( params->target, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsFenceAPPLE( void *args )
{
    struct glIsFenceAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsFenceAPPLE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsFenceAPPLE( params->fence );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsFenceNV( void *args )
{
    struct glIsFenceNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsFenceNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsFenceNV( params->fence );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsFramebuffer( void *args )
{
    struct glIsFramebuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsFramebuffer) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsFramebuffer( params->framebuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsFramebufferEXT( void *args )
{
    struct glIsFramebufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsFramebufferEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsFramebufferEXT( params->framebuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsImageHandleResidentARB( void *args )
{
    struct glIsImageHandleResidentARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsImageHandleResidentARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsImageHandleResidentARB( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsImageHandleResidentNV( void *args )
{
    struct glIsImageHandleResidentNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsImageHandleResidentNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsImageHandleResidentNV( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsMemoryObjectEXT( void *args )
{
    struct glIsMemoryObjectEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsMemoryObjectEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsMemoryObjectEXT( params->memoryObject );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsNameAMD( void *args )
{
    struct glIsNameAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsNameAMD) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsNameAMD( params->identifier, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsNamedBufferResidentNV( void *args )
{
    struct glIsNamedBufferResidentNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsNamedBufferResidentNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsNamedBufferResidentNV( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsNamedStringARB( void *args )
{
    struct glIsNamedStringARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsNamedStringARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsNamedStringARB( params->namelen, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsObjectBufferATI( void *args )
{
    struct glIsObjectBufferATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsObjectBufferATI) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsObjectBufferATI( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsOcclusionQueryNV( void *args )
{
    struct glIsOcclusionQueryNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsOcclusionQueryNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsOcclusionQueryNV( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsPathNV( void *args )
{
    struct glIsPathNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsPathNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsPathNV( params->path );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsPointInFillPathNV( void *args )
{
    struct glIsPointInFillPathNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsPointInFillPathNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsPointInFillPathNV( params->path, params->mask, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsPointInStrokePathNV( void *args )
{
    struct glIsPointInStrokePathNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsPointInStrokePathNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsPointInStrokePathNV( params->path, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsProgram( void *args )
{
    struct glIsProgram_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsProgram) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsProgram( params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsProgramARB( void *args )
{
    struct glIsProgramARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsProgramARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsProgramARB( params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsProgramNV( void *args )
{
    struct glIsProgramNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsProgramNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsProgramNV( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsProgramPipeline( void *args )
{
    struct glIsProgramPipeline_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsProgramPipeline) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsProgramPipeline( params->pipeline );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsQuery( void *args )
{
    struct glIsQuery_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsQuery) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsQuery( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsQueryARB( void *args )
{
    struct glIsQueryARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsQueryARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsQueryARB( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsRenderbuffer( void *args )
{
    struct glIsRenderbuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsRenderbuffer) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsRenderbuffer( params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsRenderbufferEXT( void *args )
{
    struct glIsRenderbufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsRenderbufferEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsRenderbufferEXT( params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsSampler( void *args )
{
    struct glIsSampler_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsSampler) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsSampler( params->sampler );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsSemaphoreEXT( void *args )
{
    struct glIsSemaphoreEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsSemaphoreEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsSemaphoreEXT( params->semaphore );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsShader( void *args )
{
    struct glIsShader_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsShader) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsShader( params->shader );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsStateNV( void *args )
{
    struct glIsStateNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsStateNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsStateNV( params->state );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsSync( void *args )
{
    struct glIsSync_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsSync) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsSync( get_unix_sync( params->sync ) );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsTextureEXT( void *args )
{
    struct glIsTextureEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsTextureEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsTextureEXT( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsTextureHandleResidentARB( void *args )
{
    struct glIsTextureHandleResidentARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsTextureHandleResidentARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsTextureHandleResidentARB( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsTextureHandleResidentNV( void *args )
{
    struct glIsTextureHandleResidentNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsTextureHandleResidentNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsTextureHandleResidentNV( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsTransformFeedback( void *args )
{
    struct glIsTransformFeedback_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsTransformFeedback) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsTransformFeedback( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsTransformFeedbackNV( void *args )
{
    struct glIsTransformFeedbackNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsTransformFeedbackNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsTransformFeedbackNV( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsVariantEnabledEXT( void *args )
{
    struct glIsVariantEnabledEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsVariantEnabledEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsVariantEnabledEXT( params->id, params->cap );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsVertexArray( void *args )
{
    struct glIsVertexArray_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsVertexArray) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsVertexArray( params->array );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsVertexArrayAPPLE( void *args )
{
    struct glIsVertexArrayAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsVertexArrayAPPLE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsVertexArrayAPPLE( params->array );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glIsVertexAttribEnabledAPPLE( void *args )
{
    struct glIsVertexAttribEnabledAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glIsVertexAttribEnabledAPPLE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsVertexAttribEnabledAPPLE( params->index, params->pname );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLGPUCopyImageSubDataNVX( void *args )
{
    struct glLGPUCopyImageSubDataNVX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLGPUCopyImageSubDataNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLGPUCopyImageSubDataNVX( params->sourceGpu, params->destinationGpuMask, params->srcName, params->srcTarget, params->srcLevel, params->srcX, params->srxY, params->srcZ, params->dstName, params->dstTarget, params->dstLevel, params->dstX, params->dstY, params->dstZ, params->width, params->height, params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLGPUInterlockNVX( void *args )
{
    struct glLGPUInterlockNVX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLGPUInterlockNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLGPUInterlockNVX();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLGPUNamedBufferSubDataNVX( void *args )
{
    struct glLGPUNamedBufferSubDataNVX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLGPUNamedBufferSubDataNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLGPUNamedBufferSubDataNVX( params->gpuMask, params->buffer, params->offset, params->size, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLabelObjectEXT( void *args )
{
    struct glLabelObjectEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLabelObjectEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLabelObjectEXT( params->type, params->object, params->length, params->label );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLightEnviSGIX( void *args )
{
    struct glLightEnviSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLightEnviSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightEnviSGIX( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLightModelx( void *args )
{
    struct glLightModelx_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLightModelx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightModelx( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLightModelxOES( void *args )
{
    struct glLightModelxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLightModelxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightModelxOES( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLightModelxv( void *args )
{
    struct glLightModelxv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLightModelxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightModelxv( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLightModelxvOES( void *args )
{
    struct glLightModelxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLightModelxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightModelxvOES( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLightx( void *args )
{
    struct glLightx_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLightx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightx( params->light, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLightxOES( void *args )
{
    struct glLightxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLightxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightxOES( params->light, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLightxv( void *args )
{
    struct glLightxv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLightxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightxv( params->light, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLightxvOES( void *args )
{
    struct glLightxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLightxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightxvOES( params->light, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLineWidthx( void *args )
{
    struct glLineWidthx_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLineWidthx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLineWidthx( params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLineWidthxOES( void *args )
{
    struct glLineWidthxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLineWidthxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLineWidthxOES( params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLinkProgram( void *args )
{
    struct glLinkProgram_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLinkProgram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLinkProgram( params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLinkProgramARB( void *args )
{
    struct glLinkProgramARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLinkProgramARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLinkProgramARB( params->programObj );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glListDrawCommandsStatesClientNV( void *args )
{
    struct glListDrawCommandsStatesClientNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glListDrawCommandsStatesClientNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glListDrawCommandsStatesClientNV( params->list, params->segment, params->indirects, params->sizes, params->states, params->fbos, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glListParameterfSGIX( void *args )
{
    struct glListParameterfSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glListParameterfSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glListParameterfSGIX( params->list, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glListParameterfvSGIX( void *args )
{
    struct glListParameterfvSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glListParameterfvSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glListParameterfvSGIX( params->list, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glListParameteriSGIX( void *args )
{
    struct glListParameteriSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glListParameteriSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glListParameteriSGIX( params->list, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glListParameterivSGIX( void *args )
{
    struct glListParameterivSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glListParameterivSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glListParameterivSGIX( params->list, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLoadIdentityDeformationMapSGIX( void *args )
{
    struct glLoadIdentityDeformationMapSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLoadIdentityDeformationMapSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadIdentityDeformationMapSGIX( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLoadMatrixx( void *args )
{
    struct glLoadMatrixx_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLoadMatrixx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadMatrixx( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLoadMatrixxOES( void *args )
{
    struct glLoadMatrixxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLoadMatrixxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadMatrixxOES( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLoadProgramNV( void *args )
{
    struct glLoadProgramNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLoadProgramNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadProgramNV( params->target, params->id, params->len, params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLoadTransposeMatrixd( void *args )
{
    struct glLoadTransposeMatrixd_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLoadTransposeMatrixd) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadTransposeMatrixd( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLoadTransposeMatrixdARB( void *args )
{
    struct glLoadTransposeMatrixdARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLoadTransposeMatrixdARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadTransposeMatrixdARB( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLoadTransposeMatrixf( void *args )
{
    struct glLoadTransposeMatrixf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLoadTransposeMatrixf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadTransposeMatrixf( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLoadTransposeMatrixfARB( void *args )
{
    struct glLoadTransposeMatrixfARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLoadTransposeMatrixfARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadTransposeMatrixfARB( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLoadTransposeMatrixxOES( void *args )
{
    struct glLoadTransposeMatrixxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLoadTransposeMatrixxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadTransposeMatrixxOES( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glLockArraysEXT( void *args )
{
    struct glLockArraysEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glLockArraysEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLockArraysEXT( params->first, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMTexCoord2fSGIS( void *args )
{
    struct glMTexCoord2fSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMTexCoord2fSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMTexCoord2fSGIS( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMTexCoord2fvSGIS( void *args )
{
    struct glMTexCoord2fvSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMTexCoord2fvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMTexCoord2fvSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMakeBufferNonResidentNV( void *args )
{
    struct glMakeBufferNonResidentNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMakeBufferNonResidentNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeBufferNonResidentNV( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMakeBufferResidentNV( void *args )
{
    struct glMakeBufferResidentNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMakeBufferResidentNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeBufferResidentNV( params->target, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMakeImageHandleNonResidentARB( void *args )
{
    struct glMakeImageHandleNonResidentARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMakeImageHandleNonResidentARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeImageHandleNonResidentARB( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMakeImageHandleNonResidentNV( void *args )
{
    struct glMakeImageHandleNonResidentNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMakeImageHandleNonResidentNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeImageHandleNonResidentNV( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMakeImageHandleResidentARB( void *args )
{
    struct glMakeImageHandleResidentARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMakeImageHandleResidentARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeImageHandleResidentARB( params->handle, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMakeImageHandleResidentNV( void *args )
{
    struct glMakeImageHandleResidentNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMakeImageHandleResidentNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeImageHandleResidentNV( params->handle, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMakeNamedBufferNonResidentNV( void *args )
{
    struct glMakeNamedBufferNonResidentNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMakeNamedBufferNonResidentNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeNamedBufferNonResidentNV( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMakeNamedBufferResidentNV( void *args )
{
    struct glMakeNamedBufferResidentNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMakeNamedBufferResidentNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeNamedBufferResidentNV( params->buffer, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMakeTextureHandleNonResidentARB( void *args )
{
    struct glMakeTextureHandleNonResidentARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMakeTextureHandleNonResidentARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeTextureHandleNonResidentARB( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMakeTextureHandleNonResidentNV( void *args )
{
    struct glMakeTextureHandleNonResidentNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMakeTextureHandleNonResidentNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeTextureHandleNonResidentNV( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMakeTextureHandleResidentARB( void *args )
{
    struct glMakeTextureHandleResidentARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMakeTextureHandleResidentARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeTextureHandleResidentARB( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMakeTextureHandleResidentNV( void *args )
{
    struct glMakeTextureHandleResidentNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMakeTextureHandleResidentNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeTextureHandleResidentNV( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMap1xOES( void *args )
{
    struct glMap1xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMap1xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMap1xOES( params->target, params->u1, params->u2, params->stride, params->order, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMap2xOES( void *args )
{
    struct glMap2xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMap2xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMap2xOES( params->target, params->u1, params->u2, params->ustride, params->uorder, params->v1, params->v2, params->vstride, params->vorder, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapBuffer( void *args )
{
    struct glMapBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapBuffer) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glMapBuffer( params->target, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapBufferARB( void *args )
{
    struct glMapBufferARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapBufferARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glMapBufferARB( params->target, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapBufferRange( void *args )
{
    struct glMapBufferRange_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapBufferRange) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glMapBufferRange( params->target, params->offset, params->length, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapControlPointsNV( void *args )
{
    struct glMapControlPointsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapControlPointsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapControlPointsNV( params->target, params->index, params->type, params->ustride, params->vstride, params->uorder, params->vorder, params->packed, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapGrid1xOES( void *args )
{
    struct glMapGrid1xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapGrid1xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapGrid1xOES( params->n, params->u1, params->u2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapGrid2xOES( void *args )
{
    struct glMapGrid2xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapGrid2xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapGrid2xOES( params->n, params->u1, params->u2, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapNamedBuffer( void *args )
{
    struct glMapNamedBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapNamedBuffer) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glMapNamedBuffer( params->buffer, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapNamedBufferEXT( void *args )
{
    struct glMapNamedBufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapNamedBufferEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glMapNamedBufferEXT( params->buffer, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapNamedBufferRange( void *args )
{
    struct glMapNamedBufferRange_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapNamedBufferRange) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glMapNamedBufferRange( params->buffer, params->offset, params->length, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapNamedBufferRangeEXT( void *args )
{
    struct glMapNamedBufferRangeEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapNamedBufferRangeEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glMapNamedBufferRangeEXT( params->buffer, params->offset, params->length, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapObjectBufferATI( void *args )
{
    struct glMapObjectBufferATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapObjectBufferATI) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glMapObjectBufferATI( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapParameterfvNV( void *args )
{
    struct glMapParameterfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapParameterfvNV( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapParameterivNV( void *args )
{
    struct glMapParameterivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapParameterivNV( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapTexture2DINTEL( void *args )
{
    struct glMapTexture2DINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapTexture2DINTEL) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glMapTexture2DINTEL( params->texture, params->level, params->access, params->stride, params->layout );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapVertexAttrib1dAPPLE( void *args )
{
    struct glMapVertexAttrib1dAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapVertexAttrib1dAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapVertexAttrib1dAPPLE( params->index, params->size, params->u1, params->u2, params->stride, params->order, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapVertexAttrib1fAPPLE( void *args )
{
    struct glMapVertexAttrib1fAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapVertexAttrib1fAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapVertexAttrib1fAPPLE( params->index, params->size, params->u1, params->u2, params->stride, params->order, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapVertexAttrib2dAPPLE( void *args )
{
    struct glMapVertexAttrib2dAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapVertexAttrib2dAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapVertexAttrib2dAPPLE( params->index, params->size, params->u1, params->u2, params->ustride, params->uorder, params->v1, params->v2, params->vstride, params->vorder, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMapVertexAttrib2fAPPLE( void *args )
{
    struct glMapVertexAttrib2fAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMapVertexAttrib2fAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapVertexAttrib2fAPPLE( params->index, params->size, params->u1, params->u2, params->ustride, params->uorder, params->v1, params->v2, params->vstride, params->vorder, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMaterialx( void *args )
{
    struct glMaterialx_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMaterialx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaterialx( params->face, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMaterialxOES( void *args )
{
    struct glMaterialxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMaterialxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaterialxOES( params->face, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMaterialxv( void *args )
{
    struct glMaterialxv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMaterialxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaterialxv( params->face, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMaterialxvOES( void *args )
{
    struct glMaterialxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMaterialxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaterialxvOES( params->face, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixFrustumEXT( void *args )
{
    struct glMatrixFrustumEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixFrustumEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixFrustumEXT( params->mode, params->left, params->right, params->bottom, params->top, params->zNear, params->zFar );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixIndexPointerARB( void *args )
{
    struct glMatrixIndexPointerARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixIndexPointerARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixIndexPointerARB( params->size, params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixIndexubvARB( void *args )
{
    struct glMatrixIndexubvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixIndexubvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixIndexubvARB( params->size, params->indices );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixIndexuivARB( void *args )
{
    struct glMatrixIndexuivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixIndexuivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixIndexuivARB( params->size, params->indices );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixIndexusvARB( void *args )
{
    struct glMatrixIndexusvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixIndexusvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixIndexusvARB( params->size, params->indices );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixLoad3x2fNV( void *args )
{
    struct glMatrixLoad3x2fNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixLoad3x2fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixLoad3x2fNV( params->matrixMode, params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixLoad3x3fNV( void *args )
{
    struct glMatrixLoad3x3fNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixLoad3x3fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixLoad3x3fNV( params->matrixMode, params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixLoadIdentityEXT( void *args )
{
    struct glMatrixLoadIdentityEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixLoadIdentityEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixLoadIdentityEXT( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixLoadTranspose3x3fNV( void *args )
{
    struct glMatrixLoadTranspose3x3fNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixLoadTranspose3x3fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixLoadTranspose3x3fNV( params->matrixMode, params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixLoadTransposedEXT( void *args )
{
    struct glMatrixLoadTransposedEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixLoadTransposedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixLoadTransposedEXT( params->mode, params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixLoadTransposefEXT( void *args )
{
    struct glMatrixLoadTransposefEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixLoadTransposefEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixLoadTransposefEXT( params->mode, params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixLoaddEXT( void *args )
{
    struct glMatrixLoaddEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixLoaddEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixLoaddEXT( params->mode, params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixLoadfEXT( void *args )
{
    struct glMatrixLoadfEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixLoadfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixLoadfEXT( params->mode, params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixMult3x2fNV( void *args )
{
    struct glMatrixMult3x2fNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixMult3x2fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixMult3x2fNV( params->matrixMode, params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixMult3x3fNV( void *args )
{
    struct glMatrixMult3x3fNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixMult3x3fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixMult3x3fNV( params->matrixMode, params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixMultTranspose3x3fNV( void *args )
{
    struct glMatrixMultTranspose3x3fNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixMultTranspose3x3fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixMultTranspose3x3fNV( params->matrixMode, params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixMultTransposedEXT( void *args )
{
    struct glMatrixMultTransposedEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixMultTransposedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixMultTransposedEXT( params->mode, params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixMultTransposefEXT( void *args )
{
    struct glMatrixMultTransposefEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixMultTransposefEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixMultTransposefEXT( params->mode, params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixMultdEXT( void *args )
{
    struct glMatrixMultdEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixMultdEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixMultdEXT( params->mode, params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixMultfEXT( void *args )
{
    struct glMatrixMultfEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixMultfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixMultfEXT( params->mode, params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixOrthoEXT( void *args )
{
    struct glMatrixOrthoEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixOrthoEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixOrthoEXT( params->mode, params->left, params->right, params->bottom, params->top, params->zNear, params->zFar );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixPopEXT( void *args )
{
    struct glMatrixPopEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixPopEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixPopEXT( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixPushEXT( void *args )
{
    struct glMatrixPushEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixPushEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixPushEXT( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixRotatedEXT( void *args )
{
    struct glMatrixRotatedEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixRotatedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixRotatedEXT( params->mode, params->angle, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixRotatefEXT( void *args )
{
    struct glMatrixRotatefEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixRotatefEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixRotatefEXT( params->mode, params->angle, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixScaledEXT( void *args )
{
    struct glMatrixScaledEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixScaledEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixScaledEXT( params->mode, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixScalefEXT( void *args )
{
    struct glMatrixScalefEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixScalefEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixScalefEXT( params->mode, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixTranslatedEXT( void *args )
{
    struct glMatrixTranslatedEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixTranslatedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixTranslatedEXT( params->mode, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMatrixTranslatefEXT( void *args )
{
    struct glMatrixTranslatefEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMatrixTranslatefEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixTranslatefEXT( params->mode, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMaxShaderCompilerThreadsARB( void *args )
{
    struct glMaxShaderCompilerThreadsARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMaxShaderCompilerThreadsARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaxShaderCompilerThreadsARB( params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMaxShaderCompilerThreadsKHR( void *args )
{
    struct glMaxShaderCompilerThreadsKHR_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMaxShaderCompilerThreadsKHR) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaxShaderCompilerThreadsKHR( params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMemoryBarrier( void *args )
{
    struct glMemoryBarrier_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMemoryBarrier) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMemoryBarrier( params->barriers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMemoryBarrierByRegion( void *args )
{
    struct glMemoryBarrierByRegion_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMemoryBarrierByRegion) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMemoryBarrierByRegion( params->barriers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMemoryBarrierEXT( void *args )
{
    struct glMemoryBarrierEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMemoryBarrierEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMemoryBarrierEXT( params->barriers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMemoryObjectParameterivEXT( void *args )
{
    struct glMemoryObjectParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMemoryObjectParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMemoryObjectParameterivEXT( params->memoryObject, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMinSampleShading( void *args )
{
    struct glMinSampleShading_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMinSampleShading) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMinSampleShading( params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMinSampleShadingARB( void *args )
{
    struct glMinSampleShadingARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMinSampleShadingARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMinSampleShadingARB( params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMinmax( void *args )
{
    struct glMinmax_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMinmax) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMinmax( params->target, params->internalformat, params->sink );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMinmaxEXT( void *args )
{
    struct glMinmaxEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMinmaxEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMinmaxEXT( params->target, params->internalformat, params->sink );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultMatrixx( void *args )
{
    struct glMultMatrixx_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultMatrixx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultMatrixx( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultMatrixxOES( void *args )
{
    struct glMultMatrixxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultMatrixxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultMatrixxOES( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultTransposeMatrixd( void *args )
{
    struct glMultTransposeMatrixd_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultTransposeMatrixd) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultTransposeMatrixd( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultTransposeMatrixdARB( void *args )
{
    struct glMultTransposeMatrixdARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultTransposeMatrixdARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultTransposeMatrixdARB( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultTransposeMatrixf( void *args )
{
    struct glMultTransposeMatrixf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultTransposeMatrixf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultTransposeMatrixf( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultTransposeMatrixfARB( void *args )
{
    struct glMultTransposeMatrixfARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultTransposeMatrixfARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultTransposeMatrixfARB( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultTransposeMatrixxOES( void *args )
{
    struct glMultTransposeMatrixxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultTransposeMatrixxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultTransposeMatrixxOES( params->m );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawArrays( void *args )
{
    struct glMultiDrawArrays_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawArrays) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawArrays( params->mode, params->first, params->count, params->drawcount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawArraysEXT( void *args )
{
    struct glMultiDrawArraysEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawArraysEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawArraysEXT( params->mode, params->first, params->count, params->primcount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawArraysIndirect( void *args )
{
    struct glMultiDrawArraysIndirect_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawArraysIndirect) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawArraysIndirect( params->mode, params->indirect, params->drawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawArraysIndirectAMD( void *args )
{
    struct glMultiDrawArraysIndirectAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawArraysIndirectAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawArraysIndirectAMD( params->mode, params->indirect, params->primcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawArraysIndirectBindlessCountNV( void *args )
{
    struct glMultiDrawArraysIndirectBindlessCountNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawArraysIndirectBindlessCountNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawArraysIndirectBindlessCountNV( params->mode, params->indirect, params->drawCount, params->maxDrawCount, params->stride, params->vertexBufferCount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawArraysIndirectBindlessNV( void *args )
{
    struct glMultiDrawArraysIndirectBindlessNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawArraysIndirectBindlessNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawArraysIndirectBindlessNV( params->mode, params->indirect, params->drawCount, params->stride, params->vertexBufferCount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawArraysIndirectCount( void *args )
{
    struct glMultiDrawArraysIndirectCount_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawArraysIndirectCount) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawArraysIndirectCount( params->mode, params->indirect, params->drawcount, params->maxdrawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawArraysIndirectCountARB( void *args )
{
    struct glMultiDrawArraysIndirectCountARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawArraysIndirectCountARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawArraysIndirectCountARB( params->mode, params->indirect, params->drawcount, params->maxdrawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawElementArrayAPPLE( void *args )
{
    struct glMultiDrawElementArrayAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawElementArrayAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElementArrayAPPLE( params->mode, params->first, params->count, params->primcount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawElements( void *args )
{
    struct glMultiDrawElements_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawElements) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElements( params->mode, params->count, params->type, params->indices, params->drawcount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawElementsBaseVertex( void *args )
{
    struct glMultiDrawElementsBaseVertex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawElementsBaseVertex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElementsBaseVertex( params->mode, params->count, params->type, params->indices, params->drawcount, params->basevertex );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawElementsEXT( void *args )
{
    struct glMultiDrawElementsEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawElementsEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElementsEXT( params->mode, params->count, params->type, params->indices, params->primcount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawElementsIndirect( void *args )
{
    struct glMultiDrawElementsIndirect_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawElementsIndirect) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElementsIndirect( params->mode, params->type, params->indirect, params->drawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawElementsIndirectAMD( void *args )
{
    struct glMultiDrawElementsIndirectAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawElementsIndirectAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElementsIndirectAMD( params->mode, params->type, params->indirect, params->primcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawElementsIndirectBindlessCountNV( void *args )
{
    struct glMultiDrawElementsIndirectBindlessCountNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawElementsIndirectBindlessCountNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElementsIndirectBindlessCountNV( params->mode, params->type, params->indirect, params->drawCount, params->maxDrawCount, params->stride, params->vertexBufferCount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawElementsIndirectBindlessNV( void *args )
{
    struct glMultiDrawElementsIndirectBindlessNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawElementsIndirectBindlessNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElementsIndirectBindlessNV( params->mode, params->type, params->indirect, params->drawCount, params->stride, params->vertexBufferCount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawElementsIndirectCount( void *args )
{
    struct glMultiDrawElementsIndirectCount_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawElementsIndirectCount) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElementsIndirectCount( params->mode, params->type, params->indirect, params->drawcount, params->maxdrawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawElementsIndirectCountARB( void *args )
{
    struct glMultiDrawElementsIndirectCountARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawElementsIndirectCountARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElementsIndirectCountARB( params->mode, params->type, params->indirect, params->drawcount, params->maxdrawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawMeshTasksIndirectCountEXT( void *args )
{
    struct glMultiDrawMeshTasksIndirectCountEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawMeshTasksIndirectCountEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawMeshTasksIndirectCountEXT( params->indirect, params->drawcount, params->maxdrawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawMeshTasksIndirectCountNV( void *args )
{
    struct glMultiDrawMeshTasksIndirectCountNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawMeshTasksIndirectCountNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawMeshTasksIndirectCountNV( params->indirect, params->drawcount, params->maxdrawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawMeshTasksIndirectEXT( void *args )
{
    struct glMultiDrawMeshTasksIndirectEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawMeshTasksIndirectEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawMeshTasksIndirectEXT( params->indirect, params->drawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawMeshTasksIndirectNV( void *args )
{
    struct glMultiDrawMeshTasksIndirectNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawMeshTasksIndirectNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawMeshTasksIndirectNV( params->indirect, params->drawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiDrawRangeElementArrayAPPLE( void *args )
{
    struct glMultiDrawRangeElementArrayAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiDrawRangeElementArrayAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawRangeElementArrayAPPLE( params->mode, params->start, params->end, params->first, params->count, params->primcount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiModeDrawArraysIBM( void *args )
{
    struct glMultiModeDrawArraysIBM_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiModeDrawArraysIBM) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiModeDrawArraysIBM( params->mode, params->first, params->count, params->primcount, params->modestride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiModeDrawElementsIBM( void *args )
{
    struct glMultiModeDrawElementsIBM_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiModeDrawElementsIBM) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiModeDrawElementsIBM( params->mode, params->count, params->type, params->indices, params->primcount, params->modestride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexBufferEXT( void *args )
{
    struct glMultiTexBufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexBufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexBufferEXT( params->texunit, params->target, params->internalformat, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1bOES( void *args )
{
    struct glMultiTexCoord1bOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1bOES( params->texture, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1bvOES( void *args )
{
    struct glMultiTexCoord1bvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1bvOES( params->texture, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1d( void *args )
{
    struct glMultiTexCoord1d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1d( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1dARB( void *args )
{
    struct glMultiTexCoord1dARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1dARB( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1dSGIS( void *args )
{
    struct glMultiTexCoord1dSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1dSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1dSGIS( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1dv( void *args )
{
    struct glMultiTexCoord1dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1dv( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1dvARB( void *args )
{
    struct glMultiTexCoord1dvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1dvARB( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1dvSGIS( void *args )
{
    struct glMultiTexCoord1dvSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1dvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1dvSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1f( void *args )
{
    struct glMultiTexCoord1f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1f( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1fARB( void *args )
{
    struct glMultiTexCoord1fARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1fARB( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1fSGIS( void *args )
{
    struct glMultiTexCoord1fSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1fSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1fSGIS( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1fv( void *args )
{
    struct glMultiTexCoord1fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1fv( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1fvARB( void *args )
{
    struct glMultiTexCoord1fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1fvARB( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1fvSGIS( void *args )
{
    struct glMultiTexCoord1fvSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1fvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1fvSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1hNV( void *args )
{
    struct glMultiTexCoord1hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1hNV( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1hvNV( void *args )
{
    struct glMultiTexCoord1hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1hvNV( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1i( void *args )
{
    struct glMultiTexCoord1i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1i( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1iARB( void *args )
{
    struct glMultiTexCoord1iARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1iARB( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1iSGIS( void *args )
{
    struct glMultiTexCoord1iSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1iSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1iSGIS( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1iv( void *args )
{
    struct glMultiTexCoord1iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1iv( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1ivARB( void *args )
{
    struct glMultiTexCoord1ivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1ivARB( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1ivSGIS( void *args )
{
    struct glMultiTexCoord1ivSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1ivSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1ivSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1s( void *args )
{
    struct glMultiTexCoord1s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1s( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1sARB( void *args )
{
    struct glMultiTexCoord1sARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1sARB( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1sSGIS( void *args )
{
    struct glMultiTexCoord1sSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1sSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1sSGIS( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1sv( void *args )
{
    struct glMultiTexCoord1sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1sv( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1svARB( void *args )
{
    struct glMultiTexCoord1svARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1svARB( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1svSGIS( void *args )
{
    struct glMultiTexCoord1svSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1svSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1svSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1xOES( void *args )
{
    struct glMultiTexCoord1xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1xOES( params->texture, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord1xvOES( void *args )
{
    struct glMultiTexCoord1xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord1xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1xvOES( params->texture, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2bOES( void *args )
{
    struct glMultiTexCoord2bOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2bOES( params->texture, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2bvOES( void *args )
{
    struct glMultiTexCoord2bvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2bvOES( params->texture, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2d( void *args )
{
    struct glMultiTexCoord2d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2d( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2dARB( void *args )
{
    struct glMultiTexCoord2dARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2dARB( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2dSGIS( void *args )
{
    struct glMultiTexCoord2dSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2dSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2dSGIS( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2dv( void *args )
{
    struct glMultiTexCoord2dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2dv( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2dvARB( void *args )
{
    struct glMultiTexCoord2dvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2dvARB( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2dvSGIS( void *args )
{
    struct glMultiTexCoord2dvSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2dvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2dvSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2f( void *args )
{
    struct glMultiTexCoord2f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2f( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2fARB( void *args )
{
    struct glMultiTexCoord2fARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2fARB( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2fSGIS( void *args )
{
    struct glMultiTexCoord2fSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2fSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2fSGIS( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2fv( void *args )
{
    struct glMultiTexCoord2fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2fv( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2fvARB( void *args )
{
    struct glMultiTexCoord2fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2fvARB( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2fvSGIS( void *args )
{
    struct glMultiTexCoord2fvSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2fvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2fvSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2hNV( void *args )
{
    struct glMultiTexCoord2hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2hNV( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2hvNV( void *args )
{
    struct glMultiTexCoord2hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2hvNV( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2i( void *args )
{
    struct glMultiTexCoord2i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2i( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2iARB( void *args )
{
    struct glMultiTexCoord2iARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2iARB( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2iSGIS( void *args )
{
    struct glMultiTexCoord2iSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2iSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2iSGIS( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2iv( void *args )
{
    struct glMultiTexCoord2iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2iv( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2ivARB( void *args )
{
    struct glMultiTexCoord2ivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2ivARB( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2ivSGIS( void *args )
{
    struct glMultiTexCoord2ivSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2ivSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2ivSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2s( void *args )
{
    struct glMultiTexCoord2s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2s( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2sARB( void *args )
{
    struct glMultiTexCoord2sARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2sARB( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2sSGIS( void *args )
{
    struct glMultiTexCoord2sSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2sSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2sSGIS( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2sv( void *args )
{
    struct glMultiTexCoord2sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2sv( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2svARB( void *args )
{
    struct glMultiTexCoord2svARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2svARB( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2svSGIS( void *args )
{
    struct glMultiTexCoord2svSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2svSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2svSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2xOES( void *args )
{
    struct glMultiTexCoord2xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2xOES( params->texture, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord2xvOES( void *args )
{
    struct glMultiTexCoord2xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord2xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2xvOES( params->texture, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3bOES( void *args )
{
    struct glMultiTexCoord3bOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3bOES( params->texture, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3bvOES( void *args )
{
    struct glMultiTexCoord3bvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3bvOES( params->texture, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3d( void *args )
{
    struct glMultiTexCoord3d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3d( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3dARB( void *args )
{
    struct glMultiTexCoord3dARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3dARB( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3dSGIS( void *args )
{
    struct glMultiTexCoord3dSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3dSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3dSGIS( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3dv( void *args )
{
    struct glMultiTexCoord3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3dv( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3dvARB( void *args )
{
    struct glMultiTexCoord3dvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3dvARB( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3dvSGIS( void *args )
{
    struct glMultiTexCoord3dvSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3dvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3dvSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3f( void *args )
{
    struct glMultiTexCoord3f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3f( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3fARB( void *args )
{
    struct glMultiTexCoord3fARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3fARB( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3fSGIS( void *args )
{
    struct glMultiTexCoord3fSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3fSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3fSGIS( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3fv( void *args )
{
    struct glMultiTexCoord3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3fv( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3fvARB( void *args )
{
    struct glMultiTexCoord3fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3fvARB( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3fvSGIS( void *args )
{
    struct glMultiTexCoord3fvSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3fvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3fvSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3hNV( void *args )
{
    struct glMultiTexCoord3hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3hNV( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3hvNV( void *args )
{
    struct glMultiTexCoord3hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3hvNV( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3i( void *args )
{
    struct glMultiTexCoord3i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3i( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3iARB( void *args )
{
    struct glMultiTexCoord3iARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3iARB( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3iSGIS( void *args )
{
    struct glMultiTexCoord3iSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3iSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3iSGIS( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3iv( void *args )
{
    struct glMultiTexCoord3iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3iv( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3ivARB( void *args )
{
    struct glMultiTexCoord3ivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3ivARB( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3ivSGIS( void *args )
{
    struct glMultiTexCoord3ivSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3ivSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3ivSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3s( void *args )
{
    struct glMultiTexCoord3s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3s( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3sARB( void *args )
{
    struct glMultiTexCoord3sARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3sARB( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3sSGIS( void *args )
{
    struct glMultiTexCoord3sSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3sSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3sSGIS( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3sv( void *args )
{
    struct glMultiTexCoord3sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3sv( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3svARB( void *args )
{
    struct glMultiTexCoord3svARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3svARB( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3svSGIS( void *args )
{
    struct glMultiTexCoord3svSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3svSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3svSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3xOES( void *args )
{
    struct glMultiTexCoord3xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3xOES( params->texture, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord3xvOES( void *args )
{
    struct glMultiTexCoord3xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord3xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3xvOES( params->texture, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4bOES( void *args )
{
    struct glMultiTexCoord4bOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4bOES( params->texture, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4bvOES( void *args )
{
    struct glMultiTexCoord4bvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4bvOES( params->texture, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4d( void *args )
{
    struct glMultiTexCoord4d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4d( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4dARB( void *args )
{
    struct glMultiTexCoord4dARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4dARB( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4dSGIS( void *args )
{
    struct glMultiTexCoord4dSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4dSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4dSGIS( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4dv( void *args )
{
    struct glMultiTexCoord4dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4dv( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4dvARB( void *args )
{
    struct glMultiTexCoord4dvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4dvARB( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4dvSGIS( void *args )
{
    struct glMultiTexCoord4dvSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4dvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4dvSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4f( void *args )
{
    struct glMultiTexCoord4f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4f( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4fARB( void *args )
{
    struct glMultiTexCoord4fARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4fARB( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4fSGIS( void *args )
{
    struct glMultiTexCoord4fSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4fSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4fSGIS( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4fv( void *args )
{
    struct glMultiTexCoord4fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4fv( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4fvARB( void *args )
{
    struct glMultiTexCoord4fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4fvARB( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4fvSGIS( void *args )
{
    struct glMultiTexCoord4fvSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4fvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4fvSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4hNV( void *args )
{
    struct glMultiTexCoord4hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4hNV( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4hvNV( void *args )
{
    struct glMultiTexCoord4hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4hvNV( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4i( void *args )
{
    struct glMultiTexCoord4i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4i( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4iARB( void *args )
{
    struct glMultiTexCoord4iARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4iARB( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4iSGIS( void *args )
{
    struct glMultiTexCoord4iSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4iSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4iSGIS( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4iv( void *args )
{
    struct glMultiTexCoord4iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4iv( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4ivARB( void *args )
{
    struct glMultiTexCoord4ivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4ivARB( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4ivSGIS( void *args )
{
    struct glMultiTexCoord4ivSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4ivSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4ivSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4s( void *args )
{
    struct glMultiTexCoord4s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4s( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4sARB( void *args )
{
    struct glMultiTexCoord4sARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4sARB( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4sSGIS( void *args )
{
    struct glMultiTexCoord4sSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4sSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4sSGIS( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4sv( void *args )
{
    struct glMultiTexCoord4sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4sv( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4svARB( void *args )
{
    struct glMultiTexCoord4svARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4svARB( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4svSGIS( void *args )
{
    struct glMultiTexCoord4svSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4svSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4svSGIS( params->target, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4x( void *args )
{
    struct glMultiTexCoord4x_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4x) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4x( params->texture, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4xOES( void *args )
{
    struct glMultiTexCoord4xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4xOES( params->texture, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoord4xvOES( void *args )
{
    struct glMultiTexCoord4xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoord4xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4xvOES( params->texture, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoordP1ui( void *args )
{
    struct glMultiTexCoordP1ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoordP1ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordP1ui( params->texture, params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoordP1uiv( void *args )
{
    struct glMultiTexCoordP1uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoordP1uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordP1uiv( params->texture, params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoordP2ui( void *args )
{
    struct glMultiTexCoordP2ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoordP2ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordP2ui( params->texture, params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoordP2uiv( void *args )
{
    struct glMultiTexCoordP2uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoordP2uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordP2uiv( params->texture, params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoordP3ui( void *args )
{
    struct glMultiTexCoordP3ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoordP3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordP3ui( params->texture, params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoordP3uiv( void *args )
{
    struct glMultiTexCoordP3uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoordP3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordP3uiv( params->texture, params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoordP4ui( void *args )
{
    struct glMultiTexCoordP4ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoordP4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordP4ui( params->texture, params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoordP4uiv( void *args )
{
    struct glMultiTexCoordP4uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoordP4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordP4uiv( params->texture, params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoordPointerEXT( void *args )
{
    struct glMultiTexCoordPointerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoordPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordPointerEXT( params->texunit, params->size, params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexCoordPointerSGIS( void *args )
{
    struct glMultiTexCoordPointerSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexCoordPointerSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordPointerSGIS( params->target, params->size, params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexEnvfEXT( void *args )
{
    struct glMultiTexEnvfEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexEnvfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexEnvfEXT( params->texunit, params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexEnvfvEXT( void *args )
{
    struct glMultiTexEnvfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexEnvfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexEnvfvEXT( params->texunit, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexEnviEXT( void *args )
{
    struct glMultiTexEnviEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexEnviEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexEnviEXT( params->texunit, params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexEnvivEXT( void *args )
{
    struct glMultiTexEnvivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexEnvivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexEnvivEXT( params->texunit, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexGendEXT( void *args )
{
    struct glMultiTexGendEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexGendEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexGendEXT( params->texunit, params->coord, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexGendvEXT( void *args )
{
    struct glMultiTexGendvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexGendvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexGendvEXT( params->texunit, params->coord, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexGenfEXT( void *args )
{
    struct glMultiTexGenfEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexGenfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexGenfEXT( params->texunit, params->coord, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexGenfvEXT( void *args )
{
    struct glMultiTexGenfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexGenfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexGenfvEXT( params->texunit, params->coord, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexGeniEXT( void *args )
{
    struct glMultiTexGeniEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexGeniEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexGeniEXT( params->texunit, params->coord, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexGenivEXT( void *args )
{
    struct glMultiTexGenivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexGenivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexGenivEXT( params->texunit, params->coord, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexImage1DEXT( void *args )
{
    struct glMultiTexImage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexImage1DEXT( params->texunit, params->target, params->level, params->internalformat, params->width, params->border, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexImage2DEXT( void *args )
{
    struct glMultiTexImage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexImage2DEXT( params->texunit, params->target, params->level, params->internalformat, params->width, params->height, params->border, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexImage3DEXT( void *args )
{
    struct glMultiTexImage3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexImage3DEXT( params->texunit, params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->border, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexParameterIivEXT( void *args )
{
    struct glMultiTexParameterIivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexParameterIivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexParameterIivEXT( params->texunit, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexParameterIuivEXT( void *args )
{
    struct glMultiTexParameterIuivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexParameterIuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexParameterIuivEXT( params->texunit, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexParameterfEXT( void *args )
{
    struct glMultiTexParameterfEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexParameterfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexParameterfEXT( params->texunit, params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexParameterfvEXT( void *args )
{
    struct glMultiTexParameterfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexParameterfvEXT( params->texunit, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexParameteriEXT( void *args )
{
    struct glMultiTexParameteriEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexParameteriEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexParameteriEXT( params->texunit, params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexParameterivEXT( void *args )
{
    struct glMultiTexParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexParameterivEXT( params->texunit, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexRenderbufferEXT( void *args )
{
    struct glMultiTexRenderbufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexRenderbufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexRenderbufferEXT( params->texunit, params->target, params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexSubImage1DEXT( void *args )
{
    struct glMultiTexSubImage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexSubImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexSubImage1DEXT( params->texunit, params->target, params->level, params->xoffset, params->width, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexSubImage2DEXT( void *args )
{
    struct glMultiTexSubImage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexSubImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexSubImage2DEXT( params->texunit, params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMultiTexSubImage3DEXT( void *args )
{
    struct glMultiTexSubImage3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMultiTexSubImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexSubImage3DEXT( params->texunit, params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMulticastBarrierNV( void *args )
{
    struct glMulticastBarrierNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMulticastBarrierNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastBarrierNV();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMulticastBlitFramebufferNV( void *args )
{
    struct glMulticastBlitFramebufferNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMulticastBlitFramebufferNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastBlitFramebufferNV( params->srcGpu, params->dstGpu, params->srcX0, params->srcY0, params->srcX1, params->srcY1, params->dstX0, params->dstY0, params->dstX1, params->dstY1, params->mask, params->filter );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMulticastBufferSubDataNV( void *args )
{
    struct glMulticastBufferSubDataNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMulticastBufferSubDataNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastBufferSubDataNV( params->gpuMask, params->buffer, params->offset, params->size, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMulticastCopyBufferSubDataNV( void *args )
{
    struct glMulticastCopyBufferSubDataNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMulticastCopyBufferSubDataNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastCopyBufferSubDataNV( params->readGpu, params->writeGpuMask, params->readBuffer, params->writeBuffer, params->readOffset, params->writeOffset, params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMulticastCopyImageSubDataNV( void *args )
{
    struct glMulticastCopyImageSubDataNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMulticastCopyImageSubDataNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastCopyImageSubDataNV( params->srcGpu, params->dstGpuMask, params->srcName, params->srcTarget, params->srcLevel, params->srcX, params->srcY, params->srcZ, params->dstName, params->dstTarget, params->dstLevel, params->dstX, params->dstY, params->dstZ, params->srcWidth, params->srcHeight, params->srcDepth );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMulticastFramebufferSampleLocationsfvNV( void *args )
{
    struct glMulticastFramebufferSampleLocationsfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMulticastFramebufferSampleLocationsfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastFramebufferSampleLocationsfvNV( params->gpu, params->framebuffer, params->start, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMulticastGetQueryObjecti64vNV( void *args )
{
    struct glMulticastGetQueryObjecti64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMulticastGetQueryObjecti64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastGetQueryObjecti64vNV( params->gpu, params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMulticastGetQueryObjectivNV( void *args )
{
    struct glMulticastGetQueryObjectivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMulticastGetQueryObjectivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastGetQueryObjectivNV( params->gpu, params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMulticastGetQueryObjectui64vNV( void *args )
{
    struct glMulticastGetQueryObjectui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMulticastGetQueryObjectui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastGetQueryObjectui64vNV( params->gpu, params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMulticastGetQueryObjectuivNV( void *args )
{
    struct glMulticastGetQueryObjectuivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMulticastGetQueryObjectuivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastGetQueryObjectuivNV( params->gpu, params->id, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMulticastScissorArrayvNVX( void *args )
{
    struct glMulticastScissorArrayvNVX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMulticastScissorArrayvNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastScissorArrayvNVX( params->gpu, params->first, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMulticastViewportArrayvNVX( void *args )
{
    struct glMulticastViewportArrayvNVX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMulticastViewportArrayvNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastViewportArrayvNVX( params->gpu, params->first, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMulticastViewportPositionWScaleNVX( void *args )
{
    struct glMulticastViewportPositionWScaleNVX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMulticastViewportPositionWScaleNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastViewportPositionWScaleNVX( params->gpu, params->index, params->xcoeff, params->ycoeff );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glMulticastWaitSyncNV( void *args )
{
    struct glMulticastWaitSyncNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glMulticastWaitSyncNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastWaitSyncNV( params->signalGpu, params->waitGpuMask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedBufferAttachMemoryNV( void *args )
{
    struct glNamedBufferAttachMemoryNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedBufferAttachMemoryNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedBufferAttachMemoryNV( params->buffer, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedBufferData( void *args )
{
    struct glNamedBufferData_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedBufferData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedBufferData( params->buffer, params->size, params->data, params->usage );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedBufferDataEXT( void *args )
{
    struct glNamedBufferDataEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedBufferDataEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedBufferDataEXT( params->buffer, params->size, params->data, params->usage );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedBufferPageCommitmentARB( void *args )
{
    struct glNamedBufferPageCommitmentARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedBufferPageCommitmentARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedBufferPageCommitmentARB( params->buffer, params->offset, params->size, params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedBufferPageCommitmentEXT( void *args )
{
    struct glNamedBufferPageCommitmentEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedBufferPageCommitmentEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedBufferPageCommitmentEXT( params->buffer, params->offset, params->size, params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedBufferPageCommitmentMemNV( void *args )
{
    struct glNamedBufferPageCommitmentMemNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedBufferPageCommitmentMemNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedBufferPageCommitmentMemNV( params->buffer, params->offset, params->size, params->memory, params->memOffset, params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedBufferStorage( void *args )
{
    struct glNamedBufferStorage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedBufferStorage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedBufferStorage( params->buffer, params->size, params->data, params->flags );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedBufferStorageEXT( void *args )
{
    struct glNamedBufferStorageEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedBufferStorageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedBufferStorageEXT( params->buffer, params->size, params->data, params->flags );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedBufferStorageMemEXT( void *args )
{
    struct glNamedBufferStorageMemEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedBufferStorageMemEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedBufferStorageMemEXT( params->buffer, params->size, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedBufferSubData( void *args )
{
    struct glNamedBufferSubData_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedBufferSubData( params->buffer, params->offset, params->size, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedBufferSubDataEXT( void *args )
{
    struct glNamedBufferSubDataEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedBufferSubDataEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedBufferSubDataEXT( params->buffer, params->offset, params->size, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedCopyBufferSubDataEXT( void *args )
{
    struct glNamedCopyBufferSubDataEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedCopyBufferSubDataEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedCopyBufferSubDataEXT( params->readBuffer, params->writeBuffer, params->readOffset, params->writeOffset, params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferDrawBuffer( void *args )
{
    struct glNamedFramebufferDrawBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferDrawBuffer) return STATUS_NOT_IMPLEMENTED;
    wrap_glNamedFramebufferDrawBuffer( params->teb, params->framebuffer, params->buf, funcs->p_glNamedFramebufferDrawBuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferDrawBuffers( void *args )
{
    struct glNamedFramebufferDrawBuffers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferDrawBuffers) return STATUS_NOT_IMPLEMENTED;
    wrap_glNamedFramebufferDrawBuffers( params->teb, params->framebuffer, params->n, params->bufs, funcs->p_glNamedFramebufferDrawBuffers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferParameteri( void *args )
{
    struct glNamedFramebufferParameteri_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferParameteri) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glNamedFramebufferParameteri( framebuffer, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferParameteriEXT( void *args )
{
    struct glNamedFramebufferParameteriEXT_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferParameteriEXT) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glNamedFramebufferParameteriEXT( framebuffer, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferReadBuffer( void *args )
{
    struct glNamedFramebufferReadBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferReadBuffer) return STATUS_NOT_IMPLEMENTED;
    wrap_glNamedFramebufferReadBuffer( params->teb, params->framebuffer, params->src, funcs->p_glNamedFramebufferReadBuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferRenderbuffer( void *args )
{
    struct glNamedFramebufferRenderbuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferRenderbuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferRenderbuffer( params->framebuffer, params->attachment, params->renderbuffertarget, params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferRenderbufferEXT( void *args )
{
    struct glNamedFramebufferRenderbufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferRenderbufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferRenderbufferEXT( params->framebuffer, params->attachment, params->renderbuffertarget, params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferSampleLocationsfvARB( void *args )
{
    struct glNamedFramebufferSampleLocationsfvARB_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferSampleLocationsfvARB) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glNamedFramebufferSampleLocationsfvARB( framebuffer, params->start, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferSampleLocationsfvNV( void *args )
{
    struct glNamedFramebufferSampleLocationsfvNV_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferSampleLocationsfvNV) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glNamedFramebufferSampleLocationsfvNV( framebuffer, params->start, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferSamplePositionsfvAMD( void *args )
{
    struct glNamedFramebufferSamplePositionsfvAMD_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferSamplePositionsfvAMD) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glNamedFramebufferSamplePositionsfvAMD( framebuffer, params->numsamples, params->pixelindex, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferTexture( void *args )
{
    struct glNamedFramebufferTexture_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferTexture) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferTexture( params->framebuffer, params->attachment, params->texture, params->level );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferTexture1DEXT( void *args )
{
    struct glNamedFramebufferTexture1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferTexture1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferTexture1DEXT( params->framebuffer, params->attachment, params->textarget, params->texture, params->level );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferTexture2DEXT( void *args )
{
    struct glNamedFramebufferTexture2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferTexture2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferTexture2DEXT( params->framebuffer, params->attachment, params->textarget, params->texture, params->level );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferTexture3DEXT( void *args )
{
    struct glNamedFramebufferTexture3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferTexture3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferTexture3DEXT( params->framebuffer, params->attachment, params->textarget, params->texture, params->level, params->zoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferTextureEXT( void *args )
{
    struct glNamedFramebufferTextureEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferTextureEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferTextureEXT( params->framebuffer, params->attachment, params->texture, params->level );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferTextureFaceEXT( void *args )
{
    struct glNamedFramebufferTextureFaceEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferTextureFaceEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferTextureFaceEXT( params->framebuffer, params->attachment, params->texture, params->level, params->face );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferTextureLayer( void *args )
{
    struct glNamedFramebufferTextureLayer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferTextureLayer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferTextureLayer( params->framebuffer, params->attachment, params->texture, params->level, params->layer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferTextureLayerEXT( void *args )
{
    struct glNamedFramebufferTextureLayerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferTextureLayerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferTextureLayerEXT( params->framebuffer, params->attachment, params->texture, params->level, params->layer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedFramebufferTextureMultiviewOVR( void *args )
{
    struct glNamedFramebufferTextureMultiviewOVR_params *params = args;
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedFramebufferTextureMultiviewOVR) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( params->teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glNamedFramebufferTextureMultiviewOVR( framebuffer, params->attachment, params->texture, params->level, params->baseViewIndex, params->numViews );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedProgramLocalParameter4dEXT( void *args )
{
    struct glNamedProgramLocalParameter4dEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameter4dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameter4dEXT( params->program, params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedProgramLocalParameter4dvEXT( void *args )
{
    struct glNamedProgramLocalParameter4dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameter4dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameter4dvEXT( params->program, params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedProgramLocalParameter4fEXT( void *args )
{
    struct glNamedProgramLocalParameter4fEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameter4fEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameter4fEXT( params->program, params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedProgramLocalParameter4fvEXT( void *args )
{
    struct glNamedProgramLocalParameter4fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameter4fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameter4fvEXT( params->program, params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedProgramLocalParameterI4iEXT( void *args )
{
    struct glNamedProgramLocalParameterI4iEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameterI4iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameterI4iEXT( params->program, params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedProgramLocalParameterI4ivEXT( void *args )
{
    struct glNamedProgramLocalParameterI4ivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameterI4ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameterI4ivEXT( params->program, params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedProgramLocalParameterI4uiEXT( void *args )
{
    struct glNamedProgramLocalParameterI4uiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameterI4uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameterI4uiEXT( params->program, params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedProgramLocalParameterI4uivEXT( void *args )
{
    struct glNamedProgramLocalParameterI4uivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameterI4uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameterI4uivEXT( params->program, params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedProgramLocalParameters4fvEXT( void *args )
{
    struct glNamedProgramLocalParameters4fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameters4fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameters4fvEXT( params->program, params->target, params->index, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedProgramLocalParametersI4ivEXT( void *args )
{
    struct glNamedProgramLocalParametersI4ivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedProgramLocalParametersI4ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParametersI4ivEXT( params->program, params->target, params->index, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedProgramLocalParametersI4uivEXT( void *args )
{
    struct glNamedProgramLocalParametersI4uivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedProgramLocalParametersI4uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParametersI4uivEXT( params->program, params->target, params->index, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedProgramStringEXT( void *args )
{
    struct glNamedProgramStringEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedProgramStringEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramStringEXT( params->program, params->target, params->format, params->len, params->string );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedRenderbufferStorage( void *args )
{
    struct glNamedRenderbufferStorage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedRenderbufferStorage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedRenderbufferStorage( params->renderbuffer, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedRenderbufferStorageEXT( void *args )
{
    struct glNamedRenderbufferStorageEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedRenderbufferStorageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedRenderbufferStorageEXT( params->renderbuffer, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedRenderbufferStorageMultisample( void *args )
{
    struct glNamedRenderbufferStorageMultisample_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedRenderbufferStorageMultisample) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedRenderbufferStorageMultisample( params->renderbuffer, params->samples, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedRenderbufferStorageMultisampleAdvancedAMD( void *args )
{
    struct glNamedRenderbufferStorageMultisampleAdvancedAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedRenderbufferStorageMultisampleAdvancedAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedRenderbufferStorageMultisampleAdvancedAMD( params->renderbuffer, params->samples, params->storageSamples, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedRenderbufferStorageMultisampleCoverageEXT( void *args )
{
    struct glNamedRenderbufferStorageMultisampleCoverageEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedRenderbufferStorageMultisampleCoverageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedRenderbufferStorageMultisampleCoverageEXT( params->renderbuffer, params->coverageSamples, params->colorSamples, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedRenderbufferStorageMultisampleEXT( void *args )
{
    struct glNamedRenderbufferStorageMultisampleEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedRenderbufferStorageMultisampleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedRenderbufferStorageMultisampleEXT( params->renderbuffer, params->samples, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNamedStringARB( void *args )
{
    struct glNamedStringARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNamedStringARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedStringARB( params->type, params->namelen, params->name, params->stringlen, params->string );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNewBufferRegion( void *args )
{
    struct glNewBufferRegion_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNewBufferRegion) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glNewBufferRegion( params->type );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNewObjectBufferATI( void *args )
{
    struct glNewObjectBufferATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNewObjectBufferATI) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glNewObjectBufferATI( params->size, params->pointer, params->usage );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormal3fVertex3fSUN( void *args )
{
    struct glNormal3fVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3fVertex3fSUN( params->nx, params->ny, params->nz, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormal3fVertex3fvSUN( void *args )
{
    struct glNormal3fVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3fVertex3fvSUN( params->n, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormal3hNV( void *args )
{
    struct glNormal3hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3hNV( params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormal3hvNV( void *args )
{
    struct glNormal3hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3hvNV( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormal3x( void *args )
{
    struct glNormal3x_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3x) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3x( params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormal3xOES( void *args )
{
    struct glNormal3xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3xOES( params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormal3xvOES( void *args )
{
    struct glNormal3xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormal3xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3xvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormalFormatNV( void *args )
{
    struct glNormalFormatNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalFormatNV( params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormalP3ui( void *args )
{
    struct glNormalP3ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalP3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalP3ui( params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormalP3uiv( void *args )
{
    struct glNormalP3uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalP3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalP3uiv( params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormalPointerEXT( void *args )
{
    struct glNormalPointerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalPointerEXT( params->type, params->stride, params->count, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormalPointerListIBM( void *args )
{
    struct glNormalPointerListIBM_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalPointerListIBM) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalPointerListIBM( params->type, params->stride, params->pointer, params->ptrstride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormalPointervINTEL( void *args )
{
    struct glNormalPointervINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalPointervINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalPointervINTEL( params->type, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormalStream3bATI( void *args )
{
    struct glNormalStream3bATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalStream3bATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3bATI( params->stream, params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormalStream3bvATI( void *args )
{
    struct glNormalStream3bvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalStream3bvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3bvATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormalStream3dATI( void *args )
{
    struct glNormalStream3dATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalStream3dATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3dATI( params->stream, params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormalStream3dvATI( void *args )
{
    struct glNormalStream3dvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalStream3dvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3dvATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormalStream3fATI( void *args )
{
    struct glNormalStream3fATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalStream3fATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3fATI( params->stream, params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormalStream3fvATI( void *args )
{
    struct glNormalStream3fvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalStream3fvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3fvATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormalStream3iATI( void *args )
{
    struct glNormalStream3iATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalStream3iATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3iATI( params->stream, params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormalStream3ivATI( void *args )
{
    struct glNormalStream3ivATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalStream3ivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3ivATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormalStream3sATI( void *args )
{
    struct glNormalStream3sATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalStream3sATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3sATI( params->stream, params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glNormalStream3svATI( void *args )
{
    struct glNormalStream3svATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glNormalStream3svATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3svATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glObjectLabel( void *args )
{
    struct glObjectLabel_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glObjectLabel) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glObjectLabel( params->identifier, params->name, params->length, params->label );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glObjectPtrLabel( void *args )
{
    struct glObjectPtrLabel_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glObjectPtrLabel) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glObjectPtrLabel( params->ptr, params->length, params->label );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glObjectPurgeableAPPLE( void *args )
{
    struct glObjectPurgeableAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glObjectPurgeableAPPLE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glObjectPurgeableAPPLE( params->objectType, params->name, params->option );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glObjectUnpurgeableAPPLE( void *args )
{
    struct glObjectUnpurgeableAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glObjectUnpurgeableAPPLE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glObjectUnpurgeableAPPLE( params->objectType, params->name, params->option );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glOrthof( void *args )
{
    struct glOrthof_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glOrthof) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glOrthof( params->l, params->r, params->b, params->t, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glOrthofOES( void *args )
{
    struct glOrthofOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glOrthofOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glOrthofOES( params->l, params->r, params->b, params->t, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glOrthox( void *args )
{
    struct glOrthox_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glOrthox) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glOrthox( params->l, params->r, params->b, params->t, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glOrthoxOES( void *args )
{
    struct glOrthoxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glOrthoxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glOrthoxOES( params->l, params->r, params->b, params->t, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPNTrianglesfATI( void *args )
{
    struct glPNTrianglesfATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPNTrianglesfATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPNTrianglesfATI( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPNTrianglesiATI( void *args )
{
    struct glPNTrianglesiATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPNTrianglesiATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPNTrianglesiATI( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPassTexCoordATI( void *args )
{
    struct glPassTexCoordATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPassTexCoordATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPassTexCoordATI( params->dst, params->coord, params->swizzle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPassThroughxOES( void *args )
{
    struct glPassThroughxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPassThroughxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPassThroughxOES( params->token );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPatchParameterfv( void *args )
{
    struct glPatchParameterfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPatchParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPatchParameterfv( params->pname, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPatchParameteri( void *args )
{
    struct glPatchParameteri_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPatchParameteri) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPatchParameteri( params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathColorGenNV( void *args )
{
    struct glPathColorGenNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathColorGenNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathColorGenNV( params->color, params->genMode, params->colorFormat, params->coeffs );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathCommandsNV( void *args )
{
    struct glPathCommandsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathCommandsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathCommandsNV( params->path, params->numCommands, params->commands, params->numCoords, params->coordType, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathCoordsNV( void *args )
{
    struct glPathCoordsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathCoordsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathCoordsNV( params->path, params->numCoords, params->coordType, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathCoverDepthFuncNV( void *args )
{
    struct glPathCoverDepthFuncNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathCoverDepthFuncNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathCoverDepthFuncNV( params->func );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathDashArrayNV( void *args )
{
    struct glPathDashArrayNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathDashArrayNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathDashArrayNV( params->path, params->dashCount, params->dashArray );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathFogGenNV( void *args )
{
    struct glPathFogGenNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathFogGenNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathFogGenNV( params->genMode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathGlyphIndexArrayNV( void *args )
{
    struct glPathGlyphIndexArrayNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathGlyphIndexArrayNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glPathGlyphIndexArrayNV( params->firstPathName, params->fontTarget, params->fontName, params->fontStyle, params->firstGlyphIndex, params->numGlyphs, params->pathParameterTemplate, params->emScale );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathGlyphIndexRangeNV( void *args )
{
    struct glPathGlyphIndexRangeNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathGlyphIndexRangeNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glPathGlyphIndexRangeNV( params->fontTarget, params->fontName, params->fontStyle, params->pathParameterTemplate, params->emScale, params->baseAndCount );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathGlyphRangeNV( void *args )
{
    struct glPathGlyphRangeNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathGlyphRangeNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathGlyphRangeNV( params->firstPathName, params->fontTarget, params->fontName, params->fontStyle, params->firstGlyph, params->numGlyphs, params->handleMissingGlyphs, params->pathParameterTemplate, params->emScale );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathGlyphsNV( void *args )
{
    struct glPathGlyphsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathGlyphsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathGlyphsNV( params->firstPathName, params->fontTarget, params->fontName, params->fontStyle, params->numGlyphs, params->type, params->charcodes, params->handleMissingGlyphs, params->pathParameterTemplate, params->emScale );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathMemoryGlyphIndexArrayNV( void *args )
{
    struct glPathMemoryGlyphIndexArrayNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathMemoryGlyphIndexArrayNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glPathMemoryGlyphIndexArrayNV( params->firstPathName, params->fontTarget, params->fontSize, params->fontData, params->faceIndex, params->firstGlyphIndex, params->numGlyphs, params->pathParameterTemplate, params->emScale );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathParameterfNV( void *args )
{
    struct glPathParameterfNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathParameterfNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathParameterfNV( params->path, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathParameterfvNV( void *args )
{
    struct glPathParameterfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathParameterfvNV( params->path, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathParameteriNV( void *args )
{
    struct glPathParameteriNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathParameteriNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathParameteriNV( params->path, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathParameterivNV( void *args )
{
    struct glPathParameterivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathParameterivNV( params->path, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathStencilDepthOffsetNV( void *args )
{
    struct glPathStencilDepthOffsetNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathStencilDepthOffsetNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathStencilDepthOffsetNV( params->factor, params->units );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathStencilFuncNV( void *args )
{
    struct glPathStencilFuncNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathStencilFuncNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathStencilFuncNV( params->func, params->ref, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathStringNV( void *args )
{
    struct glPathStringNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathStringNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathStringNV( params->path, params->format, params->length, params->pathString );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathSubCommandsNV( void *args )
{
    struct glPathSubCommandsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathSubCommandsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathSubCommandsNV( params->path, params->commandStart, params->commandsToDelete, params->numCommands, params->commands, params->numCoords, params->coordType, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathSubCoordsNV( void *args )
{
    struct glPathSubCoordsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathSubCoordsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathSubCoordsNV( params->path, params->coordStart, params->numCoords, params->coordType, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPathTexGenNV( void *args )
{
    struct glPathTexGenNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPathTexGenNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathTexGenNV( params->texCoordSet, params->genMode, params->components, params->coeffs );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPauseTransformFeedback( void *args )
{
    struct glPauseTransformFeedback_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPauseTransformFeedback) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPauseTransformFeedback();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPauseTransformFeedbackNV( void *args )
{
    struct glPauseTransformFeedbackNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPauseTransformFeedbackNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPauseTransformFeedbackNV();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPixelDataRangeNV( void *args )
{
    struct glPixelDataRangeNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelDataRangeNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelDataRangeNV( params->target, params->length, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPixelMapx( void *args )
{
    struct glPixelMapx_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelMapx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelMapx( params->map, params->size, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPixelStorex( void *args )
{
    struct glPixelStorex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelStorex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelStorex( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPixelTexGenParameterfSGIS( void *args )
{
    struct glPixelTexGenParameterfSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelTexGenParameterfSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTexGenParameterfSGIS( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPixelTexGenParameterfvSGIS( void *args )
{
    struct glPixelTexGenParameterfvSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelTexGenParameterfvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTexGenParameterfvSGIS( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPixelTexGenParameteriSGIS( void *args )
{
    struct glPixelTexGenParameteriSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelTexGenParameteriSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTexGenParameteriSGIS( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPixelTexGenParameterivSGIS( void *args )
{
    struct glPixelTexGenParameterivSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelTexGenParameterivSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTexGenParameterivSGIS( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPixelTexGenSGIX( void *args )
{
    struct glPixelTexGenSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelTexGenSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTexGenSGIX( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPixelTransferxOES( void *args )
{
    struct glPixelTransferxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelTransferxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTransferxOES( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPixelTransformParameterfEXT( void *args )
{
    struct glPixelTransformParameterfEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelTransformParameterfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTransformParameterfEXT( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPixelTransformParameterfvEXT( void *args )
{
    struct glPixelTransformParameterfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelTransformParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTransformParameterfvEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPixelTransformParameteriEXT( void *args )
{
    struct glPixelTransformParameteriEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelTransformParameteriEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTransformParameteriEXT( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPixelTransformParameterivEXT( void *args )
{
    struct glPixelTransformParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelTransformParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTransformParameterivEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPixelZoomxOES( void *args )
{
    struct glPixelZoomxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPixelZoomxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelZoomxOES( params->xfactor, params->yfactor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointAlongPathNV( void *args )
{
    struct glPointAlongPathNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointAlongPathNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glPointAlongPathNV( params->path, params->startSegment, params->numSegments, params->distance, params->x, params->y, params->tangentX, params->tangentY );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointParameterf( void *args )
{
    struct glPointParameterf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointParameterf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterf( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointParameterfARB( void *args )
{
    struct glPointParameterfARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointParameterfARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterfARB( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointParameterfEXT( void *args )
{
    struct glPointParameterfEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointParameterfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterfEXT( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointParameterfSGIS( void *args )
{
    struct glPointParameterfSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointParameterfSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterfSGIS( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointParameterfv( void *args )
{
    struct glPointParameterfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterfv( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointParameterfvARB( void *args )
{
    struct glPointParameterfvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointParameterfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterfvARB( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointParameterfvEXT( void *args )
{
    struct glPointParameterfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterfvEXT( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointParameterfvSGIS( void *args )
{
    struct glPointParameterfvSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointParameterfvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterfvSGIS( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointParameteri( void *args )
{
    struct glPointParameteri_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointParameteri) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameteri( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointParameteriNV( void *args )
{
    struct glPointParameteriNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointParameteriNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameteriNV( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointParameteriv( void *args )
{
    struct glPointParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameteriv( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointParameterivNV( void *args )
{
    struct glPointParameterivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterivNV( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointParameterx( void *args )
{
    struct glPointParameterx_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointParameterx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterx( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointParameterxv( void *args )
{
    struct glPointParameterxv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointParameterxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterxv( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointParameterxvOES( void *args )
{
    struct glPointParameterxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointParameterxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterxvOES( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointSizex( void *args )
{
    struct glPointSizex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointSizex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointSizex( params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPointSizexOES( void *args )
{
    struct glPointSizexOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPointSizexOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointSizexOES( params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPollAsyncSGIX( void *args )
{
    struct glPollAsyncSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPollAsyncSGIX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glPollAsyncSGIX( params->markerp );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPollInstrumentsSGIX( void *args )
{
    struct glPollInstrumentsSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPollInstrumentsSGIX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glPollInstrumentsSGIX( params->marker_p );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPolygonOffsetClamp( void *args )
{
    struct glPolygonOffsetClamp_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPolygonOffsetClamp) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPolygonOffsetClamp( params->factor, params->units, params->clamp );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPolygonOffsetClampEXT( void *args )
{
    struct glPolygonOffsetClampEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPolygonOffsetClampEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPolygonOffsetClampEXT( params->factor, params->units, params->clamp );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPolygonOffsetEXT( void *args )
{
    struct glPolygonOffsetEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPolygonOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPolygonOffsetEXT( params->factor, params->bias );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPolygonOffsetx( void *args )
{
    struct glPolygonOffsetx_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPolygonOffsetx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPolygonOffsetx( params->factor, params->units );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPolygonOffsetxOES( void *args )
{
    struct glPolygonOffsetxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPolygonOffsetxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPolygonOffsetxOES( params->factor, params->units );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPopDebugGroup( void *args )
{
    struct glPopDebugGroup_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPopDebugGroup) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPopDebugGroup();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPopGroupMarkerEXT( void *args )
{
    struct glPopGroupMarkerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPopGroupMarkerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPopGroupMarkerEXT();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPresentFrameDualFillNV( void *args )
{
    struct glPresentFrameDualFillNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPresentFrameDualFillNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPresentFrameDualFillNV( params->video_slot, params->minPresentTime, params->beginPresentTimeId, params->presentDurationId, params->type, params->target0, params->fill0, params->target1, params->fill1, params->target2, params->fill2, params->target3, params->fill3 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPresentFrameKeyedNV( void *args )
{
    struct glPresentFrameKeyedNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPresentFrameKeyedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPresentFrameKeyedNV( params->video_slot, params->minPresentTime, params->beginPresentTimeId, params->presentDurationId, params->type, params->target0, params->fill0, params->key0, params->target1, params->fill1, params->key1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPrimitiveBoundingBox( void *args )
{
    struct glPrimitiveBoundingBox_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPrimitiveBoundingBox) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPrimitiveBoundingBox( params->minX, params->minY, params->minZ, params->minW, params->maxX, params->maxY, params->maxZ, params->maxW );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPrimitiveBoundingBoxARB( void *args )
{
    struct glPrimitiveBoundingBoxARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPrimitiveBoundingBoxARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPrimitiveBoundingBoxARB( params->minX, params->minY, params->minZ, params->minW, params->maxX, params->maxY, params->maxZ, params->maxW );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPrimitiveRestartIndex( void *args )
{
    struct glPrimitiveRestartIndex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPrimitiveRestartIndex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPrimitiveRestartIndex( params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPrimitiveRestartIndexNV( void *args )
{
    struct glPrimitiveRestartIndexNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPrimitiveRestartIndexNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPrimitiveRestartIndexNV( params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPrimitiveRestartNV( void *args )
{
    struct glPrimitiveRestartNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPrimitiveRestartNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPrimitiveRestartNV();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPrioritizeTexturesEXT( void *args )
{
    struct glPrioritizeTexturesEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPrioritizeTexturesEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPrioritizeTexturesEXT( params->n, params->textures, params->priorities );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPrioritizeTexturesxOES( void *args )
{
    struct glPrioritizeTexturesxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPrioritizeTexturesxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPrioritizeTexturesxOES( params->n, params->textures, params->priorities );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramBinary( void *args )
{
    struct glProgramBinary_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramBinary) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramBinary( params->program, params->binaryFormat, params->binary, params->length );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramBufferParametersIivNV( void *args )
{
    struct glProgramBufferParametersIivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramBufferParametersIivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramBufferParametersIivNV( params->target, params->bindingIndex, params->wordIndex, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramBufferParametersIuivNV( void *args )
{
    struct glProgramBufferParametersIuivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramBufferParametersIuivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramBufferParametersIuivNV( params->target, params->bindingIndex, params->wordIndex, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramBufferParametersfvNV( void *args )
{
    struct glProgramBufferParametersfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramBufferParametersfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramBufferParametersfvNV( params->target, params->bindingIndex, params->wordIndex, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramEnvParameter4dARB( void *args )
{
    struct glProgramEnvParameter4dARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramEnvParameter4dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameter4dARB( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramEnvParameter4dvARB( void *args )
{
    struct glProgramEnvParameter4dvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramEnvParameter4dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameter4dvARB( params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramEnvParameter4fARB( void *args )
{
    struct glProgramEnvParameter4fARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramEnvParameter4fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameter4fARB( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramEnvParameter4fvARB( void *args )
{
    struct glProgramEnvParameter4fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramEnvParameter4fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameter4fvARB( params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramEnvParameterI4iNV( void *args )
{
    struct glProgramEnvParameterI4iNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramEnvParameterI4iNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameterI4iNV( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramEnvParameterI4ivNV( void *args )
{
    struct glProgramEnvParameterI4ivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramEnvParameterI4ivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameterI4ivNV( params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramEnvParameterI4uiNV( void *args )
{
    struct glProgramEnvParameterI4uiNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramEnvParameterI4uiNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameterI4uiNV( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramEnvParameterI4uivNV( void *args )
{
    struct glProgramEnvParameterI4uivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramEnvParameterI4uivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameterI4uivNV( params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramEnvParameters4fvEXT( void *args )
{
    struct glProgramEnvParameters4fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramEnvParameters4fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameters4fvEXT( params->target, params->index, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramEnvParametersI4ivNV( void *args )
{
    struct glProgramEnvParametersI4ivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramEnvParametersI4ivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParametersI4ivNV( params->target, params->index, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramEnvParametersI4uivNV( void *args )
{
    struct glProgramEnvParametersI4uivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramEnvParametersI4uivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParametersI4uivNV( params->target, params->index, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramLocalParameter4dARB( void *args )
{
    struct glProgramLocalParameter4dARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramLocalParameter4dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameter4dARB( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramLocalParameter4dvARB( void *args )
{
    struct glProgramLocalParameter4dvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramLocalParameter4dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameter4dvARB( params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramLocalParameter4fARB( void *args )
{
    struct glProgramLocalParameter4fARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramLocalParameter4fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameter4fARB( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramLocalParameter4fvARB( void *args )
{
    struct glProgramLocalParameter4fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramLocalParameter4fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameter4fvARB( params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramLocalParameterI4iNV( void *args )
{
    struct glProgramLocalParameterI4iNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramLocalParameterI4iNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameterI4iNV( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramLocalParameterI4ivNV( void *args )
{
    struct glProgramLocalParameterI4ivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramLocalParameterI4ivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameterI4ivNV( params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramLocalParameterI4uiNV( void *args )
{
    struct glProgramLocalParameterI4uiNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramLocalParameterI4uiNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameterI4uiNV( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramLocalParameterI4uivNV( void *args )
{
    struct glProgramLocalParameterI4uivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramLocalParameterI4uivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameterI4uivNV( params->target, params->index, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramLocalParameters4fvEXT( void *args )
{
    struct glProgramLocalParameters4fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramLocalParameters4fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameters4fvEXT( params->target, params->index, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramLocalParametersI4ivNV( void *args )
{
    struct glProgramLocalParametersI4ivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramLocalParametersI4ivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParametersI4ivNV( params->target, params->index, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramLocalParametersI4uivNV( void *args )
{
    struct glProgramLocalParametersI4uivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramLocalParametersI4uivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParametersI4uivNV( params->target, params->index, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramNamedParameter4dNV( void *args )
{
    struct glProgramNamedParameter4dNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramNamedParameter4dNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramNamedParameter4dNV( params->id, params->len, params->name, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramNamedParameter4dvNV( void *args )
{
    struct glProgramNamedParameter4dvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramNamedParameter4dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramNamedParameter4dvNV( params->id, params->len, params->name, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramNamedParameter4fNV( void *args )
{
    struct glProgramNamedParameter4fNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramNamedParameter4fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramNamedParameter4fNV( params->id, params->len, params->name, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramNamedParameter4fvNV( void *args )
{
    struct glProgramNamedParameter4fvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramNamedParameter4fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramNamedParameter4fvNV( params->id, params->len, params->name, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramParameter4dNV( void *args )
{
    struct glProgramParameter4dNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramParameter4dNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameter4dNV( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramParameter4dvNV( void *args )
{
    struct glProgramParameter4dvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramParameter4dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameter4dvNV( params->target, params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramParameter4fNV( void *args )
{
    struct glProgramParameter4fNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramParameter4fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameter4fNV( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramParameter4fvNV( void *args )
{
    struct glProgramParameter4fvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramParameter4fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameter4fvNV( params->target, params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramParameteri( void *args )
{
    struct glProgramParameteri_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramParameteri) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameteri( params->program, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramParameteriARB( void *args )
{
    struct glProgramParameteriARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramParameteriARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameteriARB( params->program, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramParameteriEXT( void *args )
{
    struct glProgramParameteriEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramParameteriEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameteriEXT( params->program, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramParameters4dvNV( void *args )
{
    struct glProgramParameters4dvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramParameters4dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameters4dvNV( params->target, params->index, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramParameters4fvNV( void *args )
{
    struct glProgramParameters4fvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramParameters4fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameters4fvNV( params->target, params->index, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramPathFragmentInputGenNV( void *args )
{
    struct glProgramPathFragmentInputGenNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramPathFragmentInputGenNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramPathFragmentInputGenNV( params->program, params->location, params->genMode, params->components, params->coeffs );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramStringARB( void *args )
{
    struct glProgramStringARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramStringARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramStringARB( params->target, params->format, params->len, params->string );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramSubroutineParametersuivNV( void *args )
{
    struct glProgramSubroutineParametersuivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramSubroutineParametersuivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramSubroutineParametersuivNV( params->target, params->count, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1d( void *args )
{
    struct glProgramUniform1d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1d( params->program, params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1dEXT( void *args )
{
    struct glProgramUniform1dEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1dEXT( params->program, params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1dv( void *args )
{
    struct glProgramUniform1dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1dv( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1dvEXT( void *args )
{
    struct glProgramUniform1dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1dvEXT( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1f( void *args )
{
    struct glProgramUniform1f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1f( params->program, params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1fEXT( void *args )
{
    struct glProgramUniform1fEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1fEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1fEXT( params->program, params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1fv( void *args )
{
    struct glProgramUniform1fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1fv( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1fvEXT( void *args )
{
    struct glProgramUniform1fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1fvEXT( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1i( void *args )
{
    struct glProgramUniform1i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1i( params->program, params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1i64ARB( void *args )
{
    struct glProgramUniform1i64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1i64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1i64ARB( params->program, params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1i64NV( void *args )
{
    struct glProgramUniform1i64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1i64NV( params->program, params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1i64vARB( void *args )
{
    struct glProgramUniform1i64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1i64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1i64vARB( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1i64vNV( void *args )
{
    struct glProgramUniform1i64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1i64vNV( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1iEXT( void *args )
{
    struct glProgramUniform1iEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1iEXT( params->program, params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1iv( void *args )
{
    struct glProgramUniform1iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1iv( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1ivEXT( void *args )
{
    struct glProgramUniform1ivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1ivEXT( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1ui( void *args )
{
    struct glProgramUniform1ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1ui( params->program, params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1ui64ARB( void *args )
{
    struct glProgramUniform1ui64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1ui64ARB( params->program, params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1ui64NV( void *args )
{
    struct glProgramUniform1ui64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1ui64NV( params->program, params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1ui64vARB( void *args )
{
    struct glProgramUniform1ui64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1ui64vARB( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1ui64vNV( void *args )
{
    struct glProgramUniform1ui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1ui64vNV( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1uiEXT( void *args )
{
    struct glProgramUniform1uiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1uiEXT( params->program, params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1uiv( void *args )
{
    struct glProgramUniform1uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1uiv( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform1uivEXT( void *args )
{
    struct glProgramUniform1uivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform1uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1uivEXT( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2d( void *args )
{
    struct glProgramUniform2d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2d( params->program, params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2dEXT( void *args )
{
    struct glProgramUniform2dEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2dEXT( params->program, params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2dv( void *args )
{
    struct glProgramUniform2dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2dv( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2dvEXT( void *args )
{
    struct glProgramUniform2dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2dvEXT( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2f( void *args )
{
    struct glProgramUniform2f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2f( params->program, params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2fEXT( void *args )
{
    struct glProgramUniform2fEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2fEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2fEXT( params->program, params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2fv( void *args )
{
    struct glProgramUniform2fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2fv( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2fvEXT( void *args )
{
    struct glProgramUniform2fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2fvEXT( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2i( void *args )
{
    struct glProgramUniform2i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2i( params->program, params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2i64ARB( void *args )
{
    struct glProgramUniform2i64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2i64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2i64ARB( params->program, params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2i64NV( void *args )
{
    struct glProgramUniform2i64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2i64NV( params->program, params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2i64vARB( void *args )
{
    struct glProgramUniform2i64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2i64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2i64vARB( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2i64vNV( void *args )
{
    struct glProgramUniform2i64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2i64vNV( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2iEXT( void *args )
{
    struct glProgramUniform2iEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2iEXT( params->program, params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2iv( void *args )
{
    struct glProgramUniform2iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2iv( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2ivEXT( void *args )
{
    struct glProgramUniform2ivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2ivEXT( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2ui( void *args )
{
    struct glProgramUniform2ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2ui( params->program, params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2ui64ARB( void *args )
{
    struct glProgramUniform2ui64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2ui64ARB( params->program, params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2ui64NV( void *args )
{
    struct glProgramUniform2ui64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2ui64NV( params->program, params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2ui64vARB( void *args )
{
    struct glProgramUniform2ui64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2ui64vARB( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2ui64vNV( void *args )
{
    struct glProgramUniform2ui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2ui64vNV( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2uiEXT( void *args )
{
    struct glProgramUniform2uiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2uiEXT( params->program, params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2uiv( void *args )
{
    struct glProgramUniform2uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2uiv( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform2uivEXT( void *args )
{
    struct glProgramUniform2uivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform2uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2uivEXT( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3d( void *args )
{
    struct glProgramUniform3d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3d( params->program, params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3dEXT( void *args )
{
    struct glProgramUniform3dEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3dEXT( params->program, params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3dv( void *args )
{
    struct glProgramUniform3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3dv( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3dvEXT( void *args )
{
    struct glProgramUniform3dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3dvEXT( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3f( void *args )
{
    struct glProgramUniform3f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3f( params->program, params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3fEXT( void *args )
{
    struct glProgramUniform3fEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3fEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3fEXT( params->program, params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3fv( void *args )
{
    struct glProgramUniform3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3fv( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3fvEXT( void *args )
{
    struct glProgramUniform3fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3fvEXT( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3i( void *args )
{
    struct glProgramUniform3i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3i( params->program, params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3i64ARB( void *args )
{
    struct glProgramUniform3i64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3i64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3i64ARB( params->program, params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3i64NV( void *args )
{
    struct glProgramUniform3i64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3i64NV( params->program, params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3i64vARB( void *args )
{
    struct glProgramUniform3i64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3i64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3i64vARB( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3i64vNV( void *args )
{
    struct glProgramUniform3i64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3i64vNV( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3iEXT( void *args )
{
    struct glProgramUniform3iEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3iEXT( params->program, params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3iv( void *args )
{
    struct glProgramUniform3iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3iv( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3ivEXT( void *args )
{
    struct glProgramUniform3ivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3ivEXT( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3ui( void *args )
{
    struct glProgramUniform3ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3ui( params->program, params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3ui64ARB( void *args )
{
    struct glProgramUniform3ui64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3ui64ARB( params->program, params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3ui64NV( void *args )
{
    struct glProgramUniform3ui64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3ui64NV( params->program, params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3ui64vARB( void *args )
{
    struct glProgramUniform3ui64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3ui64vARB( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3ui64vNV( void *args )
{
    struct glProgramUniform3ui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3ui64vNV( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3uiEXT( void *args )
{
    struct glProgramUniform3uiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3uiEXT( params->program, params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3uiv( void *args )
{
    struct glProgramUniform3uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3uiv( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform3uivEXT( void *args )
{
    struct glProgramUniform3uivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform3uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3uivEXT( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4d( void *args )
{
    struct glProgramUniform4d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4d( params->program, params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4dEXT( void *args )
{
    struct glProgramUniform4dEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4dEXT( params->program, params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4dv( void *args )
{
    struct glProgramUniform4dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4dv( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4dvEXT( void *args )
{
    struct glProgramUniform4dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4dvEXT( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4f( void *args )
{
    struct glProgramUniform4f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4f( params->program, params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4fEXT( void *args )
{
    struct glProgramUniform4fEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4fEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4fEXT( params->program, params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4fv( void *args )
{
    struct glProgramUniform4fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4fv( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4fvEXT( void *args )
{
    struct glProgramUniform4fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4fvEXT( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4i( void *args )
{
    struct glProgramUniform4i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4i( params->program, params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4i64ARB( void *args )
{
    struct glProgramUniform4i64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4i64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4i64ARB( params->program, params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4i64NV( void *args )
{
    struct glProgramUniform4i64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4i64NV( params->program, params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4i64vARB( void *args )
{
    struct glProgramUniform4i64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4i64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4i64vARB( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4i64vNV( void *args )
{
    struct glProgramUniform4i64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4i64vNV( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4iEXT( void *args )
{
    struct glProgramUniform4iEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4iEXT( params->program, params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4iv( void *args )
{
    struct glProgramUniform4iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4iv( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4ivEXT( void *args )
{
    struct glProgramUniform4ivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4ivEXT( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4ui( void *args )
{
    struct glProgramUniform4ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4ui( params->program, params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4ui64ARB( void *args )
{
    struct glProgramUniform4ui64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4ui64ARB( params->program, params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4ui64NV( void *args )
{
    struct glProgramUniform4ui64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4ui64NV( params->program, params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4ui64vARB( void *args )
{
    struct glProgramUniform4ui64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4ui64vARB( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4ui64vNV( void *args )
{
    struct glProgramUniform4ui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4ui64vNV( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4uiEXT( void *args )
{
    struct glProgramUniform4uiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4uiEXT( params->program, params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4uiv( void *args )
{
    struct glProgramUniform4uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4uiv( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniform4uivEXT( void *args )
{
    struct glProgramUniform4uivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniform4uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4uivEXT( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformHandleui64ARB( void *args )
{
    struct glProgramUniformHandleui64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformHandleui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformHandleui64ARB( params->program, params->location, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformHandleui64NV( void *args )
{
    struct glProgramUniformHandleui64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformHandleui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformHandleui64NV( params->program, params->location, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformHandleui64vARB( void *args )
{
    struct glProgramUniformHandleui64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformHandleui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformHandleui64vARB( params->program, params->location, params->count, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformHandleui64vNV( void *args )
{
    struct glProgramUniformHandleui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformHandleui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformHandleui64vNV( params->program, params->location, params->count, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix2dv( void *args )
{
    struct glProgramUniformMatrix2dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2dv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix2dvEXT( void *args )
{
    struct glProgramUniformMatrix2dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2dvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix2fv( void *args )
{
    struct glProgramUniformMatrix2fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2fv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix2fvEXT( void *args )
{
    struct glProgramUniformMatrix2fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2fvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix2x3dv( void *args )
{
    struct glProgramUniformMatrix2x3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2x3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2x3dv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix2x3dvEXT( void *args )
{
    struct glProgramUniformMatrix2x3dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2x3dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2x3dvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix2x3fv( void *args )
{
    struct glProgramUniformMatrix2x3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2x3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2x3fv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix2x3fvEXT( void *args )
{
    struct glProgramUniformMatrix2x3fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2x3fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2x3fvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix2x4dv( void *args )
{
    struct glProgramUniformMatrix2x4dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2x4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2x4dv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix2x4dvEXT( void *args )
{
    struct glProgramUniformMatrix2x4dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2x4dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2x4dvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix2x4fv( void *args )
{
    struct glProgramUniformMatrix2x4fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2x4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2x4fv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix2x4fvEXT( void *args )
{
    struct glProgramUniformMatrix2x4fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2x4fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2x4fvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix3dv( void *args )
{
    struct glProgramUniformMatrix3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3dv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix3dvEXT( void *args )
{
    struct glProgramUniformMatrix3dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3dvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix3fv( void *args )
{
    struct glProgramUniformMatrix3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3fv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix3fvEXT( void *args )
{
    struct glProgramUniformMatrix3fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3fvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix3x2dv( void *args )
{
    struct glProgramUniformMatrix3x2dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3x2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3x2dv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix3x2dvEXT( void *args )
{
    struct glProgramUniformMatrix3x2dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3x2dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3x2dvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix3x2fv( void *args )
{
    struct glProgramUniformMatrix3x2fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3x2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3x2fv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix3x2fvEXT( void *args )
{
    struct glProgramUniformMatrix3x2fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3x2fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3x2fvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix3x4dv( void *args )
{
    struct glProgramUniformMatrix3x4dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3x4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3x4dv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix3x4dvEXT( void *args )
{
    struct glProgramUniformMatrix3x4dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3x4dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3x4dvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix3x4fv( void *args )
{
    struct glProgramUniformMatrix3x4fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3x4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3x4fv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix3x4fvEXT( void *args )
{
    struct glProgramUniformMatrix3x4fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3x4fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3x4fvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix4dv( void *args )
{
    struct glProgramUniformMatrix4dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4dv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix4dvEXT( void *args )
{
    struct glProgramUniformMatrix4dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4dvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix4fv( void *args )
{
    struct glProgramUniformMatrix4fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4fv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix4fvEXT( void *args )
{
    struct glProgramUniformMatrix4fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4fvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix4x2dv( void *args )
{
    struct glProgramUniformMatrix4x2dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4x2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4x2dv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix4x2dvEXT( void *args )
{
    struct glProgramUniformMatrix4x2dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4x2dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4x2dvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix4x2fv( void *args )
{
    struct glProgramUniformMatrix4x2fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4x2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4x2fv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix4x2fvEXT( void *args )
{
    struct glProgramUniformMatrix4x2fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4x2fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4x2fvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix4x3dv( void *args )
{
    struct glProgramUniformMatrix4x3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4x3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4x3dv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix4x3dvEXT( void *args )
{
    struct glProgramUniformMatrix4x3dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4x3dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4x3dvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix4x3fv( void *args )
{
    struct glProgramUniformMatrix4x3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4x3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4x3fv( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformMatrix4x3fvEXT( void *args )
{
    struct glProgramUniformMatrix4x3fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4x3fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4x3fvEXT( params->program, params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformui64NV( void *args )
{
    struct glProgramUniformui64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformui64NV( params->program, params->location, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramUniformui64vNV( void *args )
{
    struct glProgramUniformui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramUniformui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformui64vNV( params->program, params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProgramVertexLimitNV( void *args )
{
    struct glProgramVertexLimitNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProgramVertexLimitNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramVertexLimitNV( params->target, params->limit );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProvokingVertex( void *args )
{
    struct glProvokingVertex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProvokingVertex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProvokingVertex( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glProvokingVertexEXT( void *args )
{
    struct glProvokingVertexEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glProvokingVertexEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProvokingVertexEXT( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPushClientAttribDefaultEXT( void *args )
{
    struct glPushClientAttribDefaultEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPushClientAttribDefaultEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPushClientAttribDefaultEXT( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPushDebugGroup( void *args )
{
    struct glPushDebugGroup_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPushDebugGroup) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPushDebugGroup( params->source, params->id, params->length, params->message );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glPushGroupMarkerEXT( void *args )
{
    struct glPushGroupMarkerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glPushGroupMarkerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPushGroupMarkerEXT( params->length, params->marker );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glQueryCounter( void *args )
{
    struct glQueryCounter_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glQueryCounter) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glQueryCounter( params->id, params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glQueryMatrixxOES( void *args )
{
    struct glQueryMatrixxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glQueryMatrixxOES) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glQueryMatrixxOES( params->mantissa, params->exponent );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glQueryObjectParameteruiAMD( void *args )
{
    struct glQueryObjectParameteruiAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glQueryObjectParameteruiAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glQueryObjectParameteruiAMD( params->target, params->id, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glQueryResourceNV( void *args )
{
    struct glQueryResourceNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glQueryResourceNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glQueryResourceNV( params->queryType, params->tagId, params->count, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glQueryResourceTagNV( void *args )
{
    struct glQueryResourceTagNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glQueryResourceTagNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glQueryResourceTagNV( params->tagId, params->tagString );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRasterPos2xOES( void *args )
{
    struct glRasterPos2xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos2xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2xOES( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRasterPos2xvOES( void *args )
{
    struct glRasterPos2xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos2xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2xvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRasterPos3xOES( void *args )
{
    struct glRasterPos3xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos3xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3xOES( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRasterPos3xvOES( void *args )
{
    struct glRasterPos3xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos3xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3xvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRasterPos4xOES( void *args )
{
    struct glRasterPos4xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos4xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4xOES( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRasterPos4xvOES( void *args )
{
    struct glRasterPos4xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterPos4xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4xvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRasterSamplesEXT( void *args )
{
    struct glRasterSamplesEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRasterSamplesEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterSamplesEXT( params->samples, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReadBufferRegion( void *args )
{
    struct glReadBufferRegion_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReadBufferRegion) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReadBufferRegion( params->region, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReadInstrumentsSGIX( void *args )
{
    struct glReadInstrumentsSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReadInstrumentsSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReadInstrumentsSGIX( params->marker );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReadnPixels( void *args )
{
    struct glReadnPixels_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReadnPixels) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReadnPixels( params->x, params->y, params->width, params->height, params->format, params->type, params->bufSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReadnPixelsARB( void *args )
{
    struct glReadnPixelsARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReadnPixelsARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReadnPixelsARB( params->x, params->y, params->width, params->height, params->format, params->type, params->bufSize, params->data );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRectxOES( void *args )
{
    struct glRectxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRectxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRectxOES( params->x1, params->y1, params->x2, params->y2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRectxvOES( void *args )
{
    struct glRectxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRectxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRectxvOES( params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReferencePlaneSGIX( void *args )
{
    struct glReferencePlaneSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReferencePlaneSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReferencePlaneSGIX( params->equation );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReleaseKeyedMutexWin32EXT( void *args )
{
    struct glReleaseKeyedMutexWin32EXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReleaseKeyedMutexWin32EXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glReleaseKeyedMutexWin32EXT( params->memory, params->key );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReleaseShaderCompiler( void *args )
{
    struct glReleaseShaderCompiler_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReleaseShaderCompiler) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReleaseShaderCompiler();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRenderGpuMaskNV( void *args )
{
    struct glRenderGpuMaskNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRenderGpuMaskNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRenderGpuMaskNV( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRenderbufferStorage( void *args )
{
    struct glRenderbufferStorage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRenderbufferStorage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRenderbufferStorage( params->target, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRenderbufferStorageEXT( void *args )
{
    struct glRenderbufferStorageEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRenderbufferStorageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRenderbufferStorageEXT( params->target, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRenderbufferStorageMultisample( void *args )
{
    struct glRenderbufferStorageMultisample_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRenderbufferStorageMultisample) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRenderbufferStorageMultisample( params->target, params->samples, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRenderbufferStorageMultisampleAdvancedAMD( void *args )
{
    struct glRenderbufferStorageMultisampleAdvancedAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRenderbufferStorageMultisampleAdvancedAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRenderbufferStorageMultisampleAdvancedAMD( params->target, params->samples, params->storageSamples, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRenderbufferStorageMultisampleCoverageNV( void *args )
{
    struct glRenderbufferStorageMultisampleCoverageNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRenderbufferStorageMultisampleCoverageNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRenderbufferStorageMultisampleCoverageNV( params->target, params->coverageSamples, params->colorSamples, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRenderbufferStorageMultisampleEXT( void *args )
{
    struct glRenderbufferStorageMultisampleEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRenderbufferStorageMultisampleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRenderbufferStorageMultisampleEXT( params->target, params->samples, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodePointerSUN( void *args )
{
    struct glReplacementCodePointerSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodePointerSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodePointerSUN( params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeubSUN( void *args )
{
    struct glReplacementCodeubSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeubSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeubSUN( params->code );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeubvSUN( void *args )
{
    struct glReplacementCodeubvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeubvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeubvSUN( params->code );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiColor3fVertex3fSUN( void *args )
{
    struct glReplacementCodeuiColor3fVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiColor3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiColor3fVertex3fSUN( params->rc, params->r, params->g, params->b, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiColor3fVertex3fvSUN( void *args )
{
    struct glReplacementCodeuiColor3fVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiColor3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiColor3fVertex3fvSUN( params->rc, params->c, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiColor4fNormal3fVertex3fSUN( void *args )
{
    struct glReplacementCodeuiColor4fNormal3fVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiColor4fNormal3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiColor4fNormal3fVertex3fSUN( params->rc, params->r, params->g, params->b, params->a, params->nx, params->ny, params->nz, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiColor4fNormal3fVertex3fvSUN( void *args )
{
    struct glReplacementCodeuiColor4fNormal3fVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiColor4fNormal3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiColor4fNormal3fVertex3fvSUN( params->rc, params->c, params->n, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiColor4ubVertex3fSUN( void *args )
{
    struct glReplacementCodeuiColor4ubVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiColor4ubVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiColor4ubVertex3fSUN( params->rc, params->r, params->g, params->b, params->a, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiColor4ubVertex3fvSUN( void *args )
{
    struct glReplacementCodeuiColor4ubVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiColor4ubVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiColor4ubVertex3fvSUN( params->rc, params->c, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiNormal3fVertex3fSUN( void *args )
{
    struct glReplacementCodeuiNormal3fVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiNormal3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiNormal3fVertex3fSUN( params->rc, params->nx, params->ny, params->nz, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiNormal3fVertex3fvSUN( void *args )
{
    struct glReplacementCodeuiNormal3fVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiNormal3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiNormal3fVertex3fvSUN( params->rc, params->n, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiSUN( void *args )
{
    struct glReplacementCodeuiSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiSUN( params->code );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN( void *args )
{
    struct glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN( params->rc, params->s, params->t, params->r, params->g, params->b, params->a, params->nx, params->ny, params->nz, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN( void *args )
{
    struct glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN( params->rc, params->tc, params->c, params->n, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN( void *args )
{
    struct glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN( params->rc, params->s, params->t, params->nx, params->ny, params->nz, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN( void *args )
{
    struct glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN( params->rc, params->tc, params->n, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiTexCoord2fVertex3fSUN( void *args )
{
    struct glReplacementCodeuiTexCoord2fVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiTexCoord2fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiTexCoord2fVertex3fSUN( params->rc, params->s, params->t, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiTexCoord2fVertex3fvSUN( void *args )
{
    struct glReplacementCodeuiTexCoord2fVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiTexCoord2fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiTexCoord2fVertex3fvSUN( params->rc, params->tc, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiVertex3fSUN( void *args )
{
    struct glReplacementCodeuiVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiVertex3fSUN( params->rc, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuiVertex3fvSUN( void *args )
{
    struct glReplacementCodeuiVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuiVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiVertex3fvSUN( params->rc, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeuivSUN( void *args )
{
    struct glReplacementCodeuivSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeuivSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuivSUN( params->code );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeusSUN( void *args )
{
    struct glReplacementCodeusSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeusSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeusSUN( params->code );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glReplacementCodeusvSUN( void *args )
{
    struct glReplacementCodeusvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glReplacementCodeusvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeusvSUN( params->code );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRequestResidentProgramsNV( void *args )
{
    struct glRequestResidentProgramsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRequestResidentProgramsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRequestResidentProgramsNV( params->n, params->programs );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glResetHistogram( void *args )
{
    struct glResetHistogram_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glResetHistogram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResetHistogram( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glResetHistogramEXT( void *args )
{
    struct glResetHistogramEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glResetHistogramEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResetHistogramEXT( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glResetMemoryObjectParameterNV( void *args )
{
    struct glResetMemoryObjectParameterNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glResetMemoryObjectParameterNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResetMemoryObjectParameterNV( params->memory, params->pname );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glResetMinmax( void *args )
{
    struct glResetMinmax_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glResetMinmax) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResetMinmax( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glResetMinmaxEXT( void *args )
{
    struct glResetMinmaxEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glResetMinmaxEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResetMinmaxEXT( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glResizeBuffersMESA( void *args )
{
    struct glResizeBuffersMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glResizeBuffersMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResizeBuffersMESA();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glResolveDepthValuesNV( void *args )
{
    struct glResolveDepthValuesNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glResolveDepthValuesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResolveDepthValuesNV();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glResumeTransformFeedback( void *args )
{
    struct glResumeTransformFeedback_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glResumeTransformFeedback) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResumeTransformFeedback();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glResumeTransformFeedbackNV( void *args )
{
    struct glResumeTransformFeedbackNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glResumeTransformFeedbackNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResumeTransformFeedbackNV();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRotatex( void *args )
{
    struct glRotatex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRotatex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRotatex( params->angle, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glRotatexOES( void *args )
{
    struct glRotatexOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glRotatexOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRotatexOES( params->angle, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSampleCoverage( void *args )
{
    struct glSampleCoverage_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSampleCoverage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSampleCoverage( params->value, params->invert );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSampleCoverageARB( void *args )
{
    struct glSampleCoverageARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSampleCoverageARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSampleCoverageARB( params->value, params->invert );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSampleCoveragex( void *args )
{
    struct glSampleCoveragex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSampleCoveragex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSampleCoveragex( params->value, params->invert );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSampleMapATI( void *args )
{
    struct glSampleMapATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSampleMapATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSampleMapATI( params->dst, params->interp, params->swizzle );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSampleMaskEXT( void *args )
{
    struct glSampleMaskEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSampleMaskEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSampleMaskEXT( params->value, params->invert );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSampleMaskIndexedNV( void *args )
{
    struct glSampleMaskIndexedNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSampleMaskIndexedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSampleMaskIndexedNV( params->index, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSampleMaskSGIS( void *args )
{
    struct glSampleMaskSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSampleMaskSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSampleMaskSGIS( params->value, params->invert );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSampleMaski( void *args )
{
    struct glSampleMaski_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSampleMaski) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSampleMaski( params->maskNumber, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSamplePatternEXT( void *args )
{
    struct glSamplePatternEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSamplePatternEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSamplePatternEXT( params->pattern );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSamplePatternSGIS( void *args )
{
    struct glSamplePatternSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSamplePatternSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSamplePatternSGIS( params->pattern );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSamplerParameterIiv( void *args )
{
    struct glSamplerParameterIiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSamplerParameterIiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSamplerParameterIiv( params->sampler, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSamplerParameterIuiv( void *args )
{
    struct glSamplerParameterIuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSamplerParameterIuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSamplerParameterIuiv( params->sampler, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSamplerParameterf( void *args )
{
    struct glSamplerParameterf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSamplerParameterf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSamplerParameterf( params->sampler, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSamplerParameterfv( void *args )
{
    struct glSamplerParameterfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSamplerParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSamplerParameterfv( params->sampler, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSamplerParameteri( void *args )
{
    struct glSamplerParameteri_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSamplerParameteri) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSamplerParameteri( params->sampler, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSamplerParameteriv( void *args )
{
    struct glSamplerParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSamplerParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSamplerParameteriv( params->sampler, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glScalex( void *args )
{
    struct glScalex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glScalex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScalex( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glScalexOES( void *args )
{
    struct glScalexOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glScalexOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScalexOES( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glScissorArrayv( void *args )
{
    struct glScissorArrayv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glScissorArrayv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScissorArrayv( params->first, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glScissorExclusiveArrayvNV( void *args )
{
    struct glScissorExclusiveArrayvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glScissorExclusiveArrayvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScissorExclusiveArrayvNV( params->first, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glScissorExclusiveNV( void *args )
{
    struct glScissorExclusiveNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glScissorExclusiveNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScissorExclusiveNV( params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glScissorIndexed( void *args )
{
    struct glScissorIndexed_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glScissorIndexed) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScissorIndexed( params->index, params->left, params->bottom, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glScissorIndexedv( void *args )
{
    struct glScissorIndexedv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glScissorIndexedv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScissorIndexedv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3b( void *args )
{
    struct glSecondaryColor3b_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3b) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3b( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3bEXT( void *args )
{
    struct glSecondaryColor3bEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3bEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3bEXT( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3bv( void *args )
{
    struct glSecondaryColor3bv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3bv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3bv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3bvEXT( void *args )
{
    struct glSecondaryColor3bvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3bvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3bvEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3d( void *args )
{
    struct glSecondaryColor3d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3d( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3dEXT( void *args )
{
    struct glSecondaryColor3dEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3dEXT( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3dv( void *args )
{
    struct glSecondaryColor3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3dv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3dvEXT( void *args )
{
    struct glSecondaryColor3dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3dvEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3f( void *args )
{
    struct glSecondaryColor3f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3f( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3fEXT( void *args )
{
    struct glSecondaryColor3fEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3fEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3fEXT( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3fv( void *args )
{
    struct glSecondaryColor3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3fv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3fvEXT( void *args )
{
    struct glSecondaryColor3fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3fvEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3hNV( void *args )
{
    struct glSecondaryColor3hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3hNV( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3hvNV( void *args )
{
    struct glSecondaryColor3hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3hvNV( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3i( void *args )
{
    struct glSecondaryColor3i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3i( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3iEXT( void *args )
{
    struct glSecondaryColor3iEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3iEXT( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3iv( void *args )
{
    struct glSecondaryColor3iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3iv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3ivEXT( void *args )
{
    struct glSecondaryColor3ivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3ivEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3s( void *args )
{
    struct glSecondaryColor3s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3s( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3sEXT( void *args )
{
    struct glSecondaryColor3sEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3sEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3sEXT( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3sv( void *args )
{
    struct glSecondaryColor3sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3sv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3svEXT( void *args )
{
    struct glSecondaryColor3svEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3svEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3svEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3ub( void *args )
{
    struct glSecondaryColor3ub_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3ub) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3ub( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3ubEXT( void *args )
{
    struct glSecondaryColor3ubEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3ubEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3ubEXT( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3ubv( void *args )
{
    struct glSecondaryColor3ubv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3ubv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3ubv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3ubvEXT( void *args )
{
    struct glSecondaryColor3ubvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3ubvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3ubvEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3ui( void *args )
{
    struct glSecondaryColor3ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3ui( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3uiEXT( void *args )
{
    struct glSecondaryColor3uiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3uiEXT( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3uiv( void *args )
{
    struct glSecondaryColor3uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3uiv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3uivEXT( void *args )
{
    struct glSecondaryColor3uivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3uivEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3us( void *args )
{
    struct glSecondaryColor3us_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3us) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3us( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3usEXT( void *args )
{
    struct glSecondaryColor3usEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3usEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3usEXT( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3usv( void *args )
{
    struct glSecondaryColor3usv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3usv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3usv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColor3usvEXT( void *args )
{
    struct glSecondaryColor3usvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColor3usvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3usvEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColorFormatNV( void *args )
{
    struct glSecondaryColorFormatNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColorFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColorFormatNV( params->size, params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColorP3ui( void *args )
{
    struct glSecondaryColorP3ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColorP3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColorP3ui( params->type, params->color );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColorP3uiv( void *args )
{
    struct glSecondaryColorP3uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColorP3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColorP3uiv( params->type, params->color );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColorPointer( void *args )
{
    struct glSecondaryColorPointer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColorPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColorPointer( params->size, params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColorPointerEXT( void *args )
{
    struct glSecondaryColorPointerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColorPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColorPointerEXT( params->size, params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSecondaryColorPointerListIBM( void *args )
{
    struct glSecondaryColorPointerListIBM_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSecondaryColorPointerListIBM) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColorPointerListIBM( params->size, params->type, params->stride, params->pointer, params->ptrstride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSelectPerfMonitorCountersAMD( void *args )
{
    struct glSelectPerfMonitorCountersAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSelectPerfMonitorCountersAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSelectPerfMonitorCountersAMD( params->monitor, params->enable, params->group, params->numCounters, params->counterList );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSelectTextureCoordSetSGIS( void *args )
{
    struct glSelectTextureCoordSetSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSelectTextureCoordSetSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSelectTextureCoordSetSGIS( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSelectTextureSGIS( void *args )
{
    struct glSelectTextureSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSelectTextureSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSelectTextureSGIS( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSemaphoreParameterivNV( void *args )
{
    struct glSemaphoreParameterivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSemaphoreParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSemaphoreParameterivNV( params->semaphore, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSemaphoreParameterui64vEXT( void *args )
{
    struct glSemaphoreParameterui64vEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSemaphoreParameterui64vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSemaphoreParameterui64vEXT( params->semaphore, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSeparableFilter2D( void *args )
{
    struct glSeparableFilter2D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSeparableFilter2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSeparableFilter2D( params->target, params->internalformat, params->width, params->height, params->format, params->type, params->row, params->column );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSeparableFilter2DEXT( void *args )
{
    struct glSeparableFilter2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSeparableFilter2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSeparableFilter2DEXT( params->target, params->internalformat, params->width, params->height, params->format, params->type, params->row, params->column );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSetFenceAPPLE( void *args )
{
    struct glSetFenceAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSetFenceAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSetFenceAPPLE( params->fence );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSetFenceNV( void *args )
{
    struct glSetFenceNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSetFenceNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSetFenceNV( params->fence, params->condition );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSetFragmentShaderConstantATI( void *args )
{
    struct glSetFragmentShaderConstantATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSetFragmentShaderConstantATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSetFragmentShaderConstantATI( params->dst, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSetInvariantEXT( void *args )
{
    struct glSetInvariantEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSetInvariantEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSetInvariantEXT( params->id, params->type, params->addr );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSetLocalConstantEXT( void *args )
{
    struct glSetLocalConstantEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSetLocalConstantEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSetLocalConstantEXT( params->id, params->type, params->addr );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSetMultisamplefvAMD( void *args )
{
    struct glSetMultisamplefvAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSetMultisamplefvAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSetMultisamplefvAMD( params->pname, params->index, params->val );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glShaderBinary( void *args )
{
    struct glShaderBinary_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glShaderBinary) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShaderBinary( params->count, params->shaders, params->binaryFormat, params->binary, params->length );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glShaderOp1EXT( void *args )
{
    struct glShaderOp1EXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glShaderOp1EXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShaderOp1EXT( params->op, params->res, params->arg1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glShaderOp2EXT( void *args )
{
    struct glShaderOp2EXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glShaderOp2EXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShaderOp2EXT( params->op, params->res, params->arg1, params->arg2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glShaderOp3EXT( void *args )
{
    struct glShaderOp3EXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glShaderOp3EXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShaderOp3EXT( params->op, params->res, params->arg1, params->arg2, params->arg3 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glShaderSource( void *args )
{
    struct glShaderSource_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glShaderSource) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShaderSource( params->shader, params->count, params->string, params->length );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glShaderSourceARB( void *args )
{
    struct glShaderSourceARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glShaderSourceARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShaderSourceARB( params->shaderObj, params->count, params->string, params->length );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glShaderStorageBlockBinding( void *args )
{
    struct glShaderStorageBlockBinding_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glShaderStorageBlockBinding) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShaderStorageBlockBinding( params->program, params->storageBlockIndex, params->storageBlockBinding );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glShadingRateCombinerOpsEXT( void *args )
{
    struct glShadingRateCombinerOpsEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glShadingRateCombinerOpsEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShadingRateCombinerOpsEXT( params->combinerOp0, params->combinerOp1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glShadingRateEXT( void *args )
{
    struct glShadingRateEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glShadingRateEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShadingRateEXT( params->rate );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glShadingRateImageBarrierNV( void *args )
{
    struct glShadingRateImageBarrierNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glShadingRateImageBarrierNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShadingRateImageBarrierNV( params->synchronize );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glShadingRateImagePaletteNV( void *args )
{
    struct glShadingRateImagePaletteNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glShadingRateImagePaletteNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShadingRateImagePaletteNV( params->viewport, params->first, params->count, params->rates );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glShadingRateSampleOrderCustomNV( void *args )
{
    struct glShadingRateSampleOrderCustomNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glShadingRateSampleOrderCustomNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShadingRateSampleOrderCustomNV( params->rate, params->samples, params->locations );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glShadingRateSampleOrderNV( void *args )
{
    struct glShadingRateSampleOrderNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glShadingRateSampleOrderNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShadingRateSampleOrderNV( params->order );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSharpenTexFuncSGIS( void *args )
{
    struct glSharpenTexFuncSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSharpenTexFuncSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSharpenTexFuncSGIS( params->target, params->n, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSignalSemaphoreEXT( void *args )
{
    struct glSignalSemaphoreEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSignalSemaphoreEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSignalSemaphoreEXT( params->semaphore, params->numBufferBarriers, params->buffers, params->numTextureBarriers, params->textures, params->dstLayouts );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSignalSemaphoreui64NVX( void *args )
{
    struct glSignalSemaphoreui64NVX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSignalSemaphoreui64NVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSignalSemaphoreui64NVX( params->signalGpu, params->fenceObjectCount, params->semaphoreArray, params->fenceValueArray );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSignalVkFenceNV( void *args )
{
    struct glSignalVkFenceNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSignalVkFenceNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSignalVkFenceNV( params->vkFence );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSignalVkSemaphoreNV( void *args )
{
    struct glSignalVkSemaphoreNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSignalVkSemaphoreNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSignalVkSemaphoreNV( params->vkSemaphore );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSpecializeShader( void *args )
{
    struct glSpecializeShader_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSpecializeShader) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSpecializeShader( params->shader, params->pEntryPoint, params->numSpecializationConstants, params->pConstantIndex, params->pConstantValue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSpecializeShaderARB( void *args )
{
    struct glSpecializeShaderARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSpecializeShaderARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSpecializeShaderARB( params->shader, params->pEntryPoint, params->numSpecializationConstants, params->pConstantIndex, params->pConstantValue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSpriteParameterfSGIX( void *args )
{
    struct glSpriteParameterfSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSpriteParameterfSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSpriteParameterfSGIX( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSpriteParameterfvSGIX( void *args )
{
    struct glSpriteParameterfvSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSpriteParameterfvSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSpriteParameterfvSGIX( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSpriteParameteriSGIX( void *args )
{
    struct glSpriteParameteriSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSpriteParameteriSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSpriteParameteriSGIX( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSpriteParameterivSGIX( void *args )
{
    struct glSpriteParameterivSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSpriteParameterivSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSpriteParameterivSGIX( params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStartInstrumentsSGIX( void *args )
{
    struct glStartInstrumentsSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStartInstrumentsSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStartInstrumentsSGIX();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStateCaptureNV( void *args )
{
    struct glStateCaptureNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStateCaptureNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStateCaptureNV( params->state, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStencilClearTagEXT( void *args )
{
    struct glStencilClearTagEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilClearTagEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilClearTagEXT( params->stencilTagBits, params->stencilClearTag );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStencilFillPathInstancedNV( void *args )
{
    struct glStencilFillPathInstancedNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilFillPathInstancedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilFillPathInstancedNV( params->numPaths, params->pathNameType, params->paths, params->pathBase, params->fillMode, params->mask, params->transformType, params->transformValues );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStencilFillPathNV( void *args )
{
    struct glStencilFillPathNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilFillPathNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilFillPathNV( params->path, params->fillMode, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStencilFuncSeparate( void *args )
{
    struct glStencilFuncSeparate_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilFuncSeparate) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilFuncSeparate( params->face, params->func, params->ref, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStencilFuncSeparateATI( void *args )
{
    struct glStencilFuncSeparateATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilFuncSeparateATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilFuncSeparateATI( params->frontfunc, params->backfunc, params->ref, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStencilMaskSeparate( void *args )
{
    struct glStencilMaskSeparate_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilMaskSeparate) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilMaskSeparate( params->face, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStencilOpSeparate( void *args )
{
    struct glStencilOpSeparate_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilOpSeparate) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilOpSeparate( params->face, params->sfail, params->dpfail, params->dppass );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStencilOpSeparateATI( void *args )
{
    struct glStencilOpSeparateATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilOpSeparateATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilOpSeparateATI( params->face, params->sfail, params->dpfail, params->dppass );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStencilOpValueAMD( void *args )
{
    struct glStencilOpValueAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilOpValueAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilOpValueAMD( params->face, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStencilStrokePathInstancedNV( void *args )
{
    struct glStencilStrokePathInstancedNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilStrokePathInstancedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilStrokePathInstancedNV( params->numPaths, params->pathNameType, params->paths, params->pathBase, params->reference, params->mask, params->transformType, params->transformValues );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStencilStrokePathNV( void *args )
{
    struct glStencilStrokePathNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilStrokePathNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilStrokePathNV( params->path, params->reference, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStencilThenCoverFillPathInstancedNV( void *args )
{
    struct glStencilThenCoverFillPathInstancedNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilThenCoverFillPathInstancedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilThenCoverFillPathInstancedNV( params->numPaths, params->pathNameType, params->paths, params->pathBase, params->fillMode, params->mask, params->coverMode, params->transformType, params->transformValues );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStencilThenCoverFillPathNV( void *args )
{
    struct glStencilThenCoverFillPathNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilThenCoverFillPathNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilThenCoverFillPathNV( params->path, params->fillMode, params->mask, params->coverMode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStencilThenCoverStrokePathInstancedNV( void *args )
{
    struct glStencilThenCoverStrokePathInstancedNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilThenCoverStrokePathInstancedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilThenCoverStrokePathInstancedNV( params->numPaths, params->pathNameType, params->paths, params->pathBase, params->reference, params->mask, params->coverMode, params->transformType, params->transformValues );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStencilThenCoverStrokePathNV( void *args )
{
    struct glStencilThenCoverStrokePathNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStencilThenCoverStrokePathNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilThenCoverStrokePathNV( params->path, params->reference, params->mask, params->coverMode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStopInstrumentsSGIX( void *args )
{
    struct glStopInstrumentsSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStopInstrumentsSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStopInstrumentsSGIX( params->marker );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glStringMarkerGREMEDY( void *args )
{
    struct glStringMarkerGREMEDY_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glStringMarkerGREMEDY) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStringMarkerGREMEDY( params->len, params->string );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSubpixelPrecisionBiasNV( void *args )
{
    struct glSubpixelPrecisionBiasNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSubpixelPrecisionBiasNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSubpixelPrecisionBiasNV( params->xbits, params->ybits );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSwizzleEXT( void *args )
{
    struct glSwizzleEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSwizzleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSwizzleEXT( params->res, params->in, params->outX, params->outY, params->outZ, params->outW );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glSyncTextureINTEL( void *args )
{
    struct glSyncTextureINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glSyncTextureINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSyncTextureINTEL( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTagSampleBufferSGIX( void *args )
{
    struct glTagSampleBufferSGIX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTagSampleBufferSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTagSampleBufferSGIX();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTangent3bEXT( void *args )
{
    struct glTangent3bEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTangent3bEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3bEXT( params->tx, params->ty, params->tz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTangent3bvEXT( void *args )
{
    struct glTangent3bvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTangent3bvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3bvEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTangent3dEXT( void *args )
{
    struct glTangent3dEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTangent3dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3dEXT( params->tx, params->ty, params->tz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTangent3dvEXT( void *args )
{
    struct glTangent3dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTangent3dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3dvEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTangent3fEXT( void *args )
{
    struct glTangent3fEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTangent3fEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3fEXT( params->tx, params->ty, params->tz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTangent3fvEXT( void *args )
{
    struct glTangent3fvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTangent3fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3fvEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTangent3iEXT( void *args )
{
    struct glTangent3iEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTangent3iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3iEXT( params->tx, params->ty, params->tz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTangent3ivEXT( void *args )
{
    struct glTangent3ivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTangent3ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3ivEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTangent3sEXT( void *args )
{
    struct glTangent3sEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTangent3sEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3sEXT( params->tx, params->ty, params->tz );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTangent3svEXT( void *args )
{
    struct glTangent3svEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTangent3svEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3svEXT( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTangentPointerEXT( void *args )
{
    struct glTangentPointerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTangentPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangentPointerEXT( params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTbufferMask3DFX( void *args )
{
    struct glTbufferMask3DFX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTbufferMask3DFX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTbufferMask3DFX( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTessellationFactorAMD( void *args )
{
    struct glTessellationFactorAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTessellationFactorAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTessellationFactorAMD( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTessellationModeAMD( void *args )
{
    struct glTessellationModeAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTessellationModeAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTessellationModeAMD( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTestFenceAPPLE( void *args )
{
    struct glTestFenceAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTestFenceAPPLE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glTestFenceAPPLE( params->fence );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTestFenceNV( void *args )
{
    struct glTestFenceNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTestFenceNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glTestFenceNV( params->fence );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTestObjectAPPLE( void *args )
{
    struct glTestObjectAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTestObjectAPPLE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glTestObjectAPPLE( params->object, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexAttachMemoryNV( void *args )
{
    struct glTexAttachMemoryNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexAttachMemoryNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexAttachMemoryNV( params->target, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexBuffer( void *args )
{
    struct glTexBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexBuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexBuffer( params->target, params->internalformat, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexBufferARB( void *args )
{
    struct glTexBufferARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexBufferARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexBufferARB( params->target, params->internalformat, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexBufferEXT( void *args )
{
    struct glTexBufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexBufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexBufferEXT( params->target, params->internalformat, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexBufferRange( void *args )
{
    struct glTexBufferRange_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexBufferRange) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexBufferRange( params->target, params->internalformat, params->buffer, params->offset, params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexBumpParameterfvATI( void *args )
{
    struct glTexBumpParameterfvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexBumpParameterfvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexBumpParameterfvATI( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexBumpParameterivATI( void *args )
{
    struct glTexBumpParameterivATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexBumpParameterivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexBumpParameterivATI( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord1bOES( void *args )
{
    struct glTexCoord1bOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord1bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1bOES( params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord1bvOES( void *args )
{
    struct glTexCoord1bvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord1bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1bvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord1hNV( void *args )
{
    struct glTexCoord1hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord1hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1hNV( params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord1hvNV( void *args )
{
    struct glTexCoord1hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord1hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1hvNV( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord1xOES( void *args )
{
    struct glTexCoord1xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord1xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1xOES( params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord1xvOES( void *args )
{
    struct glTexCoord1xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord1xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1xvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord2bOES( void *args )
{
    struct glTexCoord2bOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2bOES( params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord2bvOES( void *args )
{
    struct glTexCoord2bvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2bvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord2fColor3fVertex3fSUN( void *args )
{
    struct glTexCoord2fColor3fVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2fColor3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fColor3fVertex3fSUN( params->s, params->t, params->r, params->g, params->b, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord2fColor3fVertex3fvSUN( void *args )
{
    struct glTexCoord2fColor3fVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2fColor3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fColor3fVertex3fvSUN( params->tc, params->c, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord2fColor4fNormal3fVertex3fSUN( void *args )
{
    struct glTexCoord2fColor4fNormal3fVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2fColor4fNormal3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fColor4fNormal3fVertex3fSUN( params->s, params->t, params->r, params->g, params->b, params->a, params->nx, params->ny, params->nz, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord2fColor4fNormal3fVertex3fvSUN( void *args )
{
    struct glTexCoord2fColor4fNormal3fVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2fColor4fNormal3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fColor4fNormal3fVertex3fvSUN( params->tc, params->c, params->n, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord2fColor4ubVertex3fSUN( void *args )
{
    struct glTexCoord2fColor4ubVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2fColor4ubVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fColor4ubVertex3fSUN( params->s, params->t, params->r, params->g, params->b, params->a, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord2fColor4ubVertex3fvSUN( void *args )
{
    struct glTexCoord2fColor4ubVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2fColor4ubVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fColor4ubVertex3fvSUN( params->tc, params->c, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord2fNormal3fVertex3fSUN( void *args )
{
    struct glTexCoord2fNormal3fVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2fNormal3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fNormal3fVertex3fSUN( params->s, params->t, params->nx, params->ny, params->nz, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord2fNormal3fVertex3fvSUN( void *args )
{
    struct glTexCoord2fNormal3fVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2fNormal3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fNormal3fVertex3fvSUN( params->tc, params->n, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord2fVertex3fSUN( void *args )
{
    struct glTexCoord2fVertex3fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fVertex3fSUN( params->s, params->t, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord2fVertex3fvSUN( void *args )
{
    struct glTexCoord2fVertex3fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fVertex3fvSUN( params->tc, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord2hNV( void *args )
{
    struct glTexCoord2hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2hNV( params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord2hvNV( void *args )
{
    struct glTexCoord2hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2hvNV( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord2xOES( void *args )
{
    struct glTexCoord2xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2xOES( params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord2xvOES( void *args )
{
    struct glTexCoord2xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord2xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2xvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord3bOES( void *args )
{
    struct glTexCoord3bOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord3bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3bOES( params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord3bvOES( void *args )
{
    struct glTexCoord3bvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord3bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3bvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord3hNV( void *args )
{
    struct glTexCoord3hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord3hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3hNV( params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord3hvNV( void *args )
{
    struct glTexCoord3hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord3hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3hvNV( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord3xOES( void *args )
{
    struct glTexCoord3xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord3xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3xOES( params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord3xvOES( void *args )
{
    struct glTexCoord3xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord3xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3xvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord4bOES( void *args )
{
    struct glTexCoord4bOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4bOES( params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord4bvOES( void *args )
{
    struct glTexCoord4bvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4bvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord4fColor4fNormal3fVertex4fSUN( void *args )
{
    struct glTexCoord4fColor4fNormal3fVertex4fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4fColor4fNormal3fVertex4fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4fColor4fNormal3fVertex4fSUN( params->s, params->t, params->p, params->q, params->r, params->g, params->b, params->a, params->nx, params->ny, params->nz, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord4fColor4fNormal3fVertex4fvSUN( void *args )
{
    struct glTexCoord4fColor4fNormal3fVertex4fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4fColor4fNormal3fVertex4fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4fColor4fNormal3fVertex4fvSUN( params->tc, params->c, params->n, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord4fVertex4fSUN( void *args )
{
    struct glTexCoord4fVertex4fSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4fVertex4fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4fVertex4fSUN( params->s, params->t, params->p, params->q, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord4fVertex4fvSUN( void *args )
{
    struct glTexCoord4fVertex4fvSUN_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4fVertex4fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4fVertex4fvSUN( params->tc, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord4hNV( void *args )
{
    struct glTexCoord4hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4hNV( params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord4hvNV( void *args )
{
    struct glTexCoord4hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4hvNV( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord4xOES( void *args )
{
    struct glTexCoord4xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4xOES( params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoord4xvOES( void *args )
{
    struct glTexCoord4xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoord4xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4xvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoordFormatNV( void *args )
{
    struct glTexCoordFormatNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoordFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordFormatNV( params->size, params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoordP1ui( void *args )
{
    struct glTexCoordP1ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoordP1ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordP1ui( params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoordP1uiv( void *args )
{
    struct glTexCoordP1uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoordP1uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordP1uiv( params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoordP2ui( void *args )
{
    struct glTexCoordP2ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoordP2ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordP2ui( params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoordP2uiv( void *args )
{
    struct glTexCoordP2uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoordP2uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordP2uiv( params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoordP3ui( void *args )
{
    struct glTexCoordP3ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoordP3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordP3ui( params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoordP3uiv( void *args )
{
    struct glTexCoordP3uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoordP3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordP3uiv( params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoordP4ui( void *args )
{
    struct glTexCoordP4ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoordP4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordP4ui( params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoordP4uiv( void *args )
{
    struct glTexCoordP4uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoordP4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordP4uiv( params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoordPointerEXT( void *args )
{
    struct glTexCoordPointerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoordPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordPointerEXT( params->size, params->type, params->stride, params->count, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoordPointerListIBM( void *args )
{
    struct glTexCoordPointerListIBM_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoordPointerListIBM) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordPointerListIBM( params->size, params->type, params->stride, params->pointer, params->ptrstride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexCoordPointervINTEL( void *args )
{
    struct glTexCoordPointervINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexCoordPointervINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordPointervINTEL( params->size, params->type, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexEnvx( void *args )
{
    struct glTexEnvx_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexEnvx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexEnvx( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexEnvxOES( void *args )
{
    struct glTexEnvxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexEnvxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexEnvxOES( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexEnvxv( void *args )
{
    struct glTexEnvxv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexEnvxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexEnvxv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexEnvxvOES( void *args )
{
    struct glTexEnvxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexEnvxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexEnvxvOES( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexFilterFuncSGIS( void *args )
{
    struct glTexFilterFuncSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexFilterFuncSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexFilterFuncSGIS( params->target, params->filter, params->n, params->weights );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexGenxOES( void *args )
{
    struct glTexGenxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexGenxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexGenxOES( params->coord, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexGenxvOES( void *args )
{
    struct glTexGenxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexGenxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexGenxvOES( params->coord, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexImage2DMultisample( void *args )
{
    struct glTexImage2DMultisample_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexImage2DMultisample) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage2DMultisample( params->target, params->samples, params->internalformat, params->width, params->height, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexImage2DMultisampleCoverageNV( void *args )
{
    struct glTexImage2DMultisampleCoverageNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexImage2DMultisampleCoverageNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage2DMultisampleCoverageNV( params->target, params->coverageSamples, params->colorSamples, params->internalFormat, params->width, params->height, params->fixedSampleLocations );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexImage3D( void *args )
{
    struct glTexImage3D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexImage3D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage3D( params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->border, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexImage3DEXT( void *args )
{
    struct glTexImage3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage3DEXT( params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->border, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexImage3DMultisample( void *args )
{
    struct glTexImage3DMultisample_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexImage3DMultisample) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage3DMultisample( params->target, params->samples, params->internalformat, params->width, params->height, params->depth, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexImage3DMultisampleCoverageNV( void *args )
{
    struct glTexImage3DMultisampleCoverageNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexImage3DMultisampleCoverageNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage3DMultisampleCoverageNV( params->target, params->coverageSamples, params->colorSamples, params->internalFormat, params->width, params->height, params->depth, params->fixedSampleLocations );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexImage4DSGIS( void *args )
{
    struct glTexImage4DSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexImage4DSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage4DSGIS( params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->size4d, params->border, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexPageCommitmentARB( void *args )
{
    struct glTexPageCommitmentARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexPageCommitmentARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexPageCommitmentARB( params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexPageCommitmentMemNV( void *args )
{
    struct glTexPageCommitmentMemNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexPageCommitmentMemNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexPageCommitmentMemNV( params->target, params->layer, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->memory, params->offset, params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexParameterIiv( void *args )
{
    struct glTexParameterIiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexParameterIiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterIiv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexParameterIivEXT( void *args )
{
    struct glTexParameterIivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexParameterIivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterIivEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexParameterIuiv( void *args )
{
    struct glTexParameterIuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexParameterIuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterIuiv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexParameterIuivEXT( void *args )
{
    struct glTexParameterIuivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexParameterIuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterIuivEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexParameterx( void *args )
{
    struct glTexParameterx_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexParameterx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterx( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexParameterxOES( void *args )
{
    struct glTexParameterxOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexParameterxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterxOES( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexParameterxv( void *args )
{
    struct glTexParameterxv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexParameterxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterxv( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexParameterxvOES( void *args )
{
    struct glTexParameterxvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexParameterxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterxvOES( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexRenderbufferNV( void *args )
{
    struct glTexRenderbufferNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexRenderbufferNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexRenderbufferNV( params->target, params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexStorage1D( void *args )
{
    struct glTexStorage1D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexStorage1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorage1D( params->target, params->levels, params->internalformat, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexStorage1DEXT( void *args )
{
    struct glTexStorage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexStorage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorage1DEXT( params->target, params->levels, params->internalformat, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexStorage2D( void *args )
{
    struct glTexStorage2D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexStorage2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorage2D( params->target, params->levels, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexStorage2DEXT( void *args )
{
    struct glTexStorage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexStorage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorage2DEXT( params->target, params->levels, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexStorage2DMultisample( void *args )
{
    struct glTexStorage2DMultisample_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexStorage2DMultisample) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorage2DMultisample( params->target, params->samples, params->internalformat, params->width, params->height, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexStorage3D( void *args )
{
    struct glTexStorage3D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexStorage3D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorage3D( params->target, params->levels, params->internalformat, params->width, params->height, params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexStorage3DEXT( void *args )
{
    struct glTexStorage3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexStorage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorage3DEXT( params->target, params->levels, params->internalformat, params->width, params->height, params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexStorage3DMultisample( void *args )
{
    struct glTexStorage3DMultisample_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexStorage3DMultisample) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorage3DMultisample( params->target, params->samples, params->internalformat, params->width, params->height, params->depth, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexStorageMem1DEXT( void *args )
{
    struct glTexStorageMem1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexStorageMem1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorageMem1DEXT( params->target, params->levels, params->internalFormat, params->width, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexStorageMem2DEXT( void *args )
{
    struct glTexStorageMem2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexStorageMem2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorageMem2DEXT( params->target, params->levels, params->internalFormat, params->width, params->height, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexStorageMem2DMultisampleEXT( void *args )
{
    struct glTexStorageMem2DMultisampleEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexStorageMem2DMultisampleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorageMem2DMultisampleEXT( params->target, params->samples, params->internalFormat, params->width, params->height, params->fixedSampleLocations, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexStorageMem3DEXT( void *args )
{
    struct glTexStorageMem3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexStorageMem3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorageMem3DEXT( params->target, params->levels, params->internalFormat, params->width, params->height, params->depth, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexStorageMem3DMultisampleEXT( void *args )
{
    struct glTexStorageMem3DMultisampleEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexStorageMem3DMultisampleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorageMem3DMultisampleEXT( params->target, params->samples, params->internalFormat, params->width, params->height, params->depth, params->fixedSampleLocations, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexStorageSparseAMD( void *args )
{
    struct glTexStorageSparseAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexStorageSparseAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorageSparseAMD( params->target, params->internalFormat, params->width, params->height, params->depth, params->layers, params->flags );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexSubImage1DEXT( void *args )
{
    struct glTexSubImage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexSubImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexSubImage1DEXT( params->target, params->level, params->xoffset, params->width, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexSubImage2DEXT( void *args )
{
    struct glTexSubImage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexSubImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexSubImage2DEXT( params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexSubImage3D( void *args )
{
    struct glTexSubImage3D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexSubImage3D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexSubImage3D( params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexSubImage3DEXT( void *args )
{
    struct glTexSubImage3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexSubImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexSubImage3DEXT( params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexSubImage4DSGIS( void *args )
{
    struct glTexSubImage4DSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexSubImage4DSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexSubImage4DSGIS( params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->woffset, params->width, params->height, params->depth, params->size4d, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureAttachMemoryNV( void *args )
{
    struct glTextureAttachMemoryNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureAttachMemoryNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureAttachMemoryNV( params->texture, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureBarrier( void *args )
{
    struct glTextureBarrier_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureBarrier) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureBarrier();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureBarrierNV( void *args )
{
    struct glTextureBarrierNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureBarrierNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureBarrierNV();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureBuffer( void *args )
{
    struct glTextureBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureBuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureBuffer( params->texture, params->internalformat, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureBufferEXT( void *args )
{
    struct glTextureBufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureBufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureBufferEXT( params->texture, params->target, params->internalformat, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureBufferRange( void *args )
{
    struct glTextureBufferRange_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureBufferRange) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureBufferRange( params->texture, params->internalformat, params->buffer, params->offset, params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureBufferRangeEXT( void *args )
{
    struct glTextureBufferRangeEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureBufferRangeEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureBufferRangeEXT( params->texture, params->target, params->internalformat, params->buffer, params->offset, params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureColorMaskSGIS( void *args )
{
    struct glTextureColorMaskSGIS_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureColorMaskSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureColorMaskSGIS( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureImage1DEXT( void *args )
{
    struct glTextureImage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureImage1DEXT( params->texture, params->target, params->level, params->internalformat, params->width, params->border, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureImage2DEXT( void *args )
{
    struct glTextureImage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureImage2DEXT( params->texture, params->target, params->level, params->internalformat, params->width, params->height, params->border, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureImage2DMultisampleCoverageNV( void *args )
{
    struct glTextureImage2DMultisampleCoverageNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureImage2DMultisampleCoverageNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureImage2DMultisampleCoverageNV( params->texture, params->target, params->coverageSamples, params->colorSamples, params->internalFormat, params->width, params->height, params->fixedSampleLocations );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureImage2DMultisampleNV( void *args )
{
    struct glTextureImage2DMultisampleNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureImage2DMultisampleNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureImage2DMultisampleNV( params->texture, params->target, params->samples, params->internalFormat, params->width, params->height, params->fixedSampleLocations );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureImage3DEXT( void *args )
{
    struct glTextureImage3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureImage3DEXT( params->texture, params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->border, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureImage3DMultisampleCoverageNV( void *args )
{
    struct glTextureImage3DMultisampleCoverageNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureImage3DMultisampleCoverageNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureImage3DMultisampleCoverageNV( params->texture, params->target, params->coverageSamples, params->colorSamples, params->internalFormat, params->width, params->height, params->depth, params->fixedSampleLocations );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureImage3DMultisampleNV( void *args )
{
    struct glTextureImage3DMultisampleNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureImage3DMultisampleNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureImage3DMultisampleNV( params->texture, params->target, params->samples, params->internalFormat, params->width, params->height, params->depth, params->fixedSampleLocations );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureLightEXT( void *args )
{
    struct glTextureLightEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureLightEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureLightEXT( params->pname );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureMaterialEXT( void *args )
{
    struct glTextureMaterialEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureMaterialEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureMaterialEXT( params->face, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureNormalEXT( void *args )
{
    struct glTextureNormalEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureNormalEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureNormalEXT( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexturePageCommitmentEXT( void *args )
{
    struct glTexturePageCommitmentEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexturePageCommitmentEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexturePageCommitmentEXT( params->texture, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTexturePageCommitmentMemNV( void *args )
{
    struct glTexturePageCommitmentMemNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTexturePageCommitmentMemNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexturePageCommitmentMemNV( params->texture, params->layer, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->memory, params->offset, params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureParameterIiv( void *args )
{
    struct glTextureParameterIiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureParameterIiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterIiv( params->texture, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureParameterIivEXT( void *args )
{
    struct glTextureParameterIivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureParameterIivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterIivEXT( params->texture, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureParameterIuiv( void *args )
{
    struct glTextureParameterIuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureParameterIuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterIuiv( params->texture, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureParameterIuivEXT( void *args )
{
    struct glTextureParameterIuivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureParameterIuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterIuivEXT( params->texture, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureParameterf( void *args )
{
    struct glTextureParameterf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureParameterf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterf( params->texture, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureParameterfEXT( void *args )
{
    struct glTextureParameterfEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureParameterfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterfEXT( params->texture, params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureParameterfv( void *args )
{
    struct glTextureParameterfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterfv( params->texture, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureParameterfvEXT( void *args )
{
    struct glTextureParameterfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterfvEXT( params->texture, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureParameteri( void *args )
{
    struct glTextureParameteri_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureParameteri) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameteri( params->texture, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureParameteriEXT( void *args )
{
    struct glTextureParameteriEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureParameteriEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameteriEXT( params->texture, params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureParameteriv( void *args )
{
    struct glTextureParameteriv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameteriv( params->texture, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureParameterivEXT( void *args )
{
    struct glTextureParameterivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterivEXT( params->texture, params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureRangeAPPLE( void *args )
{
    struct glTextureRangeAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureRangeAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureRangeAPPLE( params->target, params->length, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureRenderbufferEXT( void *args )
{
    struct glTextureRenderbufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureRenderbufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureRenderbufferEXT( params->texture, params->target, params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureStorage1D( void *args )
{
    struct glTextureStorage1D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureStorage1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage1D( params->texture, params->levels, params->internalformat, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureStorage1DEXT( void *args )
{
    struct glTextureStorage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureStorage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage1DEXT( params->texture, params->target, params->levels, params->internalformat, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureStorage2D( void *args )
{
    struct glTextureStorage2D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureStorage2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage2D( params->texture, params->levels, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureStorage2DEXT( void *args )
{
    struct glTextureStorage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureStorage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage2DEXT( params->texture, params->target, params->levels, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureStorage2DMultisample( void *args )
{
    struct glTextureStorage2DMultisample_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureStorage2DMultisample) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage2DMultisample( params->texture, params->samples, params->internalformat, params->width, params->height, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureStorage2DMultisampleEXT( void *args )
{
    struct glTextureStorage2DMultisampleEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureStorage2DMultisampleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage2DMultisampleEXT( params->texture, params->target, params->samples, params->internalformat, params->width, params->height, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureStorage3D( void *args )
{
    struct glTextureStorage3D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureStorage3D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage3D( params->texture, params->levels, params->internalformat, params->width, params->height, params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureStorage3DEXT( void *args )
{
    struct glTextureStorage3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureStorage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage3DEXT( params->texture, params->target, params->levels, params->internalformat, params->width, params->height, params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureStorage3DMultisample( void *args )
{
    struct glTextureStorage3DMultisample_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureStorage3DMultisample) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage3DMultisample( params->texture, params->samples, params->internalformat, params->width, params->height, params->depth, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureStorage3DMultisampleEXT( void *args )
{
    struct glTextureStorage3DMultisampleEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureStorage3DMultisampleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage3DMultisampleEXT( params->texture, params->target, params->samples, params->internalformat, params->width, params->height, params->depth, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureStorageMem1DEXT( void *args )
{
    struct glTextureStorageMem1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureStorageMem1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorageMem1DEXT( params->texture, params->levels, params->internalFormat, params->width, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureStorageMem2DEXT( void *args )
{
    struct glTextureStorageMem2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureStorageMem2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorageMem2DEXT( params->texture, params->levels, params->internalFormat, params->width, params->height, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureStorageMem2DMultisampleEXT( void *args )
{
    struct glTextureStorageMem2DMultisampleEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureStorageMem2DMultisampleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorageMem2DMultisampleEXT( params->texture, params->samples, params->internalFormat, params->width, params->height, params->fixedSampleLocations, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureStorageMem3DEXT( void *args )
{
    struct glTextureStorageMem3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureStorageMem3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorageMem3DEXT( params->texture, params->levels, params->internalFormat, params->width, params->height, params->depth, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureStorageMem3DMultisampleEXT( void *args )
{
    struct glTextureStorageMem3DMultisampleEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureStorageMem3DMultisampleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorageMem3DMultisampleEXT( params->texture, params->samples, params->internalFormat, params->width, params->height, params->depth, params->fixedSampleLocations, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureStorageSparseAMD( void *args )
{
    struct glTextureStorageSparseAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureStorageSparseAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorageSparseAMD( params->texture, params->target, params->internalFormat, params->width, params->height, params->depth, params->layers, params->flags );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureSubImage1D( void *args )
{
    struct glTextureSubImage1D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureSubImage1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureSubImage1D( params->texture, params->level, params->xoffset, params->width, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureSubImage1DEXT( void *args )
{
    struct glTextureSubImage1DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureSubImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureSubImage1DEXT( params->texture, params->target, params->level, params->xoffset, params->width, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureSubImage2D( void *args )
{
    struct glTextureSubImage2D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureSubImage2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureSubImage2D( params->texture, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureSubImage2DEXT( void *args )
{
    struct glTextureSubImage2DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureSubImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureSubImage2DEXT( params->texture, params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureSubImage3D( void *args )
{
    struct glTextureSubImage3D_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureSubImage3D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureSubImage3D( params->texture, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureSubImage3DEXT( void *args )
{
    struct glTextureSubImage3DEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureSubImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureSubImage3DEXT( params->texture, params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->type, params->pixels );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTextureView( void *args )
{
    struct glTextureView_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTextureView) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureView( params->texture, params->target, params->origtexture, params->internalformat, params->minlevel, params->numlevels, params->minlayer, params->numlayers );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTrackMatrixNV( void *args )
{
    struct glTrackMatrixNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTrackMatrixNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTrackMatrixNV( params->target, params->address, params->matrix, params->transform );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTransformFeedbackAttribsNV( void *args )
{
    struct glTransformFeedbackAttribsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTransformFeedbackAttribsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTransformFeedbackAttribsNV( params->count, params->attribs, params->bufferMode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTransformFeedbackBufferBase( void *args )
{
    struct glTransformFeedbackBufferBase_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTransformFeedbackBufferBase) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTransformFeedbackBufferBase( params->xfb, params->index, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTransformFeedbackBufferRange( void *args )
{
    struct glTransformFeedbackBufferRange_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTransformFeedbackBufferRange) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTransformFeedbackBufferRange( params->xfb, params->index, params->buffer, params->offset, params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTransformFeedbackStreamAttribsNV( void *args )
{
    struct glTransformFeedbackStreamAttribsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTransformFeedbackStreamAttribsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTransformFeedbackStreamAttribsNV( params->count, params->attribs, params->nbuffers, params->bufstreams, params->bufferMode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTransformFeedbackVaryings( void *args )
{
    struct glTransformFeedbackVaryings_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTransformFeedbackVaryings) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTransformFeedbackVaryings( params->program, params->count, params->varyings, params->bufferMode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTransformFeedbackVaryingsEXT( void *args )
{
    struct glTransformFeedbackVaryingsEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTransformFeedbackVaryingsEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTransformFeedbackVaryingsEXT( params->program, params->count, params->varyings, params->bufferMode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTransformFeedbackVaryingsNV( void *args )
{
    struct glTransformFeedbackVaryingsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTransformFeedbackVaryingsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTransformFeedbackVaryingsNV( params->program, params->count, params->locations, params->bufferMode );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTransformPathNV( void *args )
{
    struct glTransformPathNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTransformPathNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTransformPathNV( params->resultPath, params->srcPath, params->transformType, params->transformValues );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTranslatex( void *args )
{
    struct glTranslatex_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTranslatex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTranslatex( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glTranslatexOES( void *args )
{
    struct glTranslatexOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glTranslatexOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTranslatexOES( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1d( void *args )
{
    struct glUniform1d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1d( params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1dv( void *args )
{
    struct glUniform1dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1dv( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1f( void *args )
{
    struct glUniform1f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1f( params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1fARB( void *args )
{
    struct glUniform1fARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1fARB( params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1fv( void *args )
{
    struct glUniform1fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1fv( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1fvARB( void *args )
{
    struct glUniform1fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1fvARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1i( void *args )
{
    struct glUniform1i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1i( params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1i64ARB( void *args )
{
    struct glUniform1i64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1i64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1i64ARB( params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1i64NV( void *args )
{
    struct glUniform1i64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1i64NV( params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1i64vARB( void *args )
{
    struct glUniform1i64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1i64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1i64vARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1i64vNV( void *args )
{
    struct glUniform1i64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1i64vNV( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1iARB( void *args )
{
    struct glUniform1iARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1iARB( params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1iv( void *args )
{
    struct glUniform1iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1iv( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1ivARB( void *args )
{
    struct glUniform1ivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1ivARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1ui( void *args )
{
    struct glUniform1ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1ui( params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1ui64ARB( void *args )
{
    struct glUniform1ui64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1ui64ARB( params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1ui64NV( void *args )
{
    struct glUniform1ui64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1ui64NV( params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1ui64vARB( void *args )
{
    struct glUniform1ui64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1ui64vARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1ui64vNV( void *args )
{
    struct glUniform1ui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1ui64vNV( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1uiEXT( void *args )
{
    struct glUniform1uiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1uiEXT( params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1uiv( void *args )
{
    struct glUniform1uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1uiv( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform1uivEXT( void *args )
{
    struct glUniform1uivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform1uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1uivEXT( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2d( void *args )
{
    struct glUniform2d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2d( params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2dv( void *args )
{
    struct glUniform2dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2dv( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2f( void *args )
{
    struct glUniform2f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2f( params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2fARB( void *args )
{
    struct glUniform2fARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2fARB( params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2fv( void *args )
{
    struct glUniform2fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2fv( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2fvARB( void *args )
{
    struct glUniform2fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2fvARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2i( void *args )
{
    struct glUniform2i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2i( params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2i64ARB( void *args )
{
    struct glUniform2i64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2i64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2i64ARB( params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2i64NV( void *args )
{
    struct glUniform2i64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2i64NV( params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2i64vARB( void *args )
{
    struct glUniform2i64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2i64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2i64vARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2i64vNV( void *args )
{
    struct glUniform2i64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2i64vNV( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2iARB( void *args )
{
    struct glUniform2iARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2iARB( params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2iv( void *args )
{
    struct glUniform2iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2iv( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2ivARB( void *args )
{
    struct glUniform2ivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2ivARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2ui( void *args )
{
    struct glUniform2ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2ui( params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2ui64ARB( void *args )
{
    struct glUniform2ui64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2ui64ARB( params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2ui64NV( void *args )
{
    struct glUniform2ui64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2ui64NV( params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2ui64vARB( void *args )
{
    struct glUniform2ui64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2ui64vARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2ui64vNV( void *args )
{
    struct glUniform2ui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2ui64vNV( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2uiEXT( void *args )
{
    struct glUniform2uiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2uiEXT( params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2uiv( void *args )
{
    struct glUniform2uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2uiv( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform2uivEXT( void *args )
{
    struct glUniform2uivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform2uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2uivEXT( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3d( void *args )
{
    struct glUniform3d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3d( params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3dv( void *args )
{
    struct glUniform3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3dv( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3f( void *args )
{
    struct glUniform3f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3f( params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3fARB( void *args )
{
    struct glUniform3fARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3fARB( params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3fv( void *args )
{
    struct glUniform3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3fv( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3fvARB( void *args )
{
    struct glUniform3fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3fvARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3i( void *args )
{
    struct glUniform3i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3i( params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3i64ARB( void *args )
{
    struct glUniform3i64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3i64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3i64ARB( params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3i64NV( void *args )
{
    struct glUniform3i64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3i64NV( params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3i64vARB( void *args )
{
    struct glUniform3i64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3i64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3i64vARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3i64vNV( void *args )
{
    struct glUniform3i64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3i64vNV( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3iARB( void *args )
{
    struct glUniform3iARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3iARB( params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3iv( void *args )
{
    struct glUniform3iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3iv( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3ivARB( void *args )
{
    struct glUniform3ivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3ivARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3ui( void *args )
{
    struct glUniform3ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3ui( params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3ui64ARB( void *args )
{
    struct glUniform3ui64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3ui64ARB( params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3ui64NV( void *args )
{
    struct glUniform3ui64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3ui64NV( params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3ui64vARB( void *args )
{
    struct glUniform3ui64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3ui64vARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3ui64vNV( void *args )
{
    struct glUniform3ui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3ui64vNV( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3uiEXT( void *args )
{
    struct glUniform3uiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3uiEXT( params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3uiv( void *args )
{
    struct glUniform3uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3uiv( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform3uivEXT( void *args )
{
    struct glUniform3uivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform3uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3uivEXT( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4d( void *args )
{
    struct glUniform4d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4d( params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4dv( void *args )
{
    struct glUniform4dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4dv( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4f( void *args )
{
    struct glUniform4f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4f( params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4fARB( void *args )
{
    struct glUniform4fARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4fARB( params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4fv( void *args )
{
    struct glUniform4fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4fv( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4fvARB( void *args )
{
    struct glUniform4fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4fvARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4i( void *args )
{
    struct glUniform4i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4i( params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4i64ARB( void *args )
{
    struct glUniform4i64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4i64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4i64ARB( params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4i64NV( void *args )
{
    struct glUniform4i64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4i64NV( params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4i64vARB( void *args )
{
    struct glUniform4i64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4i64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4i64vARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4i64vNV( void *args )
{
    struct glUniform4i64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4i64vNV( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4iARB( void *args )
{
    struct glUniform4iARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4iARB( params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4iv( void *args )
{
    struct glUniform4iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4iv( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4ivARB( void *args )
{
    struct glUniform4ivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4ivARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4ui( void *args )
{
    struct glUniform4ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4ui( params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4ui64ARB( void *args )
{
    struct glUniform4ui64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4ui64ARB( params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4ui64NV( void *args )
{
    struct glUniform4ui64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4ui64NV( params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4ui64vARB( void *args )
{
    struct glUniform4ui64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4ui64vARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4ui64vNV( void *args )
{
    struct glUniform4ui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4ui64vNV( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4uiEXT( void *args )
{
    struct glUniform4uiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4uiEXT( params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4uiv( void *args )
{
    struct glUniform4uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4uiv( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniform4uivEXT( void *args )
{
    struct glUniform4uivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniform4uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4uivEXT( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformBlockBinding( void *args )
{
    struct glUniformBlockBinding_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformBlockBinding) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformBlockBinding( params->program, params->uniformBlockIndex, params->uniformBlockBinding );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformBufferEXT( void *args )
{
    struct glUniformBufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformBufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformBufferEXT( params->program, params->location, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformHandleui64ARB( void *args )
{
    struct glUniformHandleui64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformHandleui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformHandleui64ARB( params->location, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformHandleui64NV( void *args )
{
    struct glUniformHandleui64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformHandleui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformHandleui64NV( params->location, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformHandleui64vARB( void *args )
{
    struct glUniformHandleui64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformHandleui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformHandleui64vARB( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformHandleui64vNV( void *args )
{
    struct glUniformHandleui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformHandleui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformHandleui64vNV( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix2dv( void *args )
{
    struct glUniformMatrix2dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix2dv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix2fv( void *args )
{
    struct glUniformMatrix2fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix2fv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix2fvARB( void *args )
{
    struct glUniformMatrix2fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix2fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix2fvARB( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix2x3dv( void *args )
{
    struct glUniformMatrix2x3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix2x3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix2x3dv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix2x3fv( void *args )
{
    struct glUniformMatrix2x3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix2x3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix2x3fv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix2x4dv( void *args )
{
    struct glUniformMatrix2x4dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix2x4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix2x4dv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix2x4fv( void *args )
{
    struct glUniformMatrix2x4fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix2x4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix2x4fv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix3dv( void *args )
{
    struct glUniformMatrix3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix3dv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix3fv( void *args )
{
    struct glUniformMatrix3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix3fv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix3fvARB( void *args )
{
    struct glUniformMatrix3fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix3fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix3fvARB( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix3x2dv( void *args )
{
    struct glUniformMatrix3x2dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix3x2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix3x2dv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix3x2fv( void *args )
{
    struct glUniformMatrix3x2fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix3x2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix3x2fv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix3x4dv( void *args )
{
    struct glUniformMatrix3x4dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix3x4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix3x4dv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix3x4fv( void *args )
{
    struct glUniformMatrix3x4fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix3x4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix3x4fv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix4dv( void *args )
{
    struct glUniformMatrix4dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix4dv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix4fv( void *args )
{
    struct glUniformMatrix4fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix4fv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix4fvARB( void *args )
{
    struct glUniformMatrix4fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix4fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix4fvARB( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix4x2dv( void *args )
{
    struct glUniformMatrix4x2dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix4x2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix4x2dv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix4x2fv( void *args )
{
    struct glUniformMatrix4x2fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix4x2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix4x2fv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix4x3dv( void *args )
{
    struct glUniformMatrix4x3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix4x3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix4x3dv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformMatrix4x3fv( void *args )
{
    struct glUniformMatrix4x3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformMatrix4x3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix4x3fv( params->location, params->count, params->transpose, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformSubroutinesuiv( void *args )
{
    struct glUniformSubroutinesuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformSubroutinesuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformSubroutinesuiv( params->shadertype, params->count, params->indices );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformui64NV( void *args )
{
    struct glUniformui64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformui64NV( params->location, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUniformui64vNV( void *args )
{
    struct glUniformui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUniformui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformui64vNV( params->location, params->count, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUnlockArraysEXT( void *args )
{
    struct glUnlockArraysEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUnlockArraysEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUnlockArraysEXT();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUnmapBuffer( void *args )
{
    struct glUnmapBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUnmapBuffer) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glUnmapBuffer( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUnmapBufferARB( void *args )
{
    struct glUnmapBufferARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUnmapBufferARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glUnmapBufferARB( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUnmapNamedBuffer( void *args )
{
    struct glUnmapNamedBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUnmapNamedBuffer) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glUnmapNamedBuffer( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUnmapNamedBufferEXT( void *args )
{
    struct glUnmapNamedBufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUnmapNamedBufferEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glUnmapNamedBufferEXT( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUnmapObjectBufferATI( void *args )
{
    struct glUnmapObjectBufferATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUnmapObjectBufferATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUnmapObjectBufferATI( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUnmapTexture2DINTEL( void *args )
{
    struct glUnmapTexture2DINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUnmapTexture2DINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUnmapTexture2DINTEL( params->texture, params->level );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUpdateObjectBufferATI( void *args )
{
    struct glUpdateObjectBufferATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUpdateObjectBufferATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUpdateObjectBufferATI( params->buffer, params->offset, params->size, params->pointer, params->preserve );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUploadGpuMaskNVX( void *args )
{
    struct glUploadGpuMaskNVX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUploadGpuMaskNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUploadGpuMaskNVX( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUseProgram( void *args )
{
    struct glUseProgram_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUseProgram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUseProgram( params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUseProgramObjectARB( void *args )
{
    struct glUseProgramObjectARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUseProgramObjectARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUseProgramObjectARB( params->programObj );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUseProgramStages( void *args )
{
    struct glUseProgramStages_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUseProgramStages) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUseProgramStages( params->pipeline, params->stages, params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glUseShaderProgramEXT( void *args )
{
    struct glUseShaderProgramEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glUseShaderProgramEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUseShaderProgramEXT( params->type, params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVDPAUFiniNV( void *args )
{
    struct glVDPAUFiniNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVDPAUFiniNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVDPAUFiniNV();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVDPAUGetSurfaceivNV( void *args )
{
    struct glVDPAUGetSurfaceivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVDPAUGetSurfaceivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVDPAUGetSurfaceivNV( params->surface, params->pname, params->count, params->length, params->values );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVDPAUInitNV( void *args )
{
    struct glVDPAUInitNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVDPAUInitNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVDPAUInitNV( params->vdpDevice, params->getProcAddress );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVDPAUIsSurfaceNV( void *args )
{
    struct glVDPAUIsSurfaceNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVDPAUIsSurfaceNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glVDPAUIsSurfaceNV( params->surface );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVDPAUMapSurfacesNV( void *args )
{
    struct glVDPAUMapSurfacesNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVDPAUMapSurfacesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVDPAUMapSurfacesNV( params->numSurfaces, params->surfaces );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVDPAURegisterOutputSurfaceNV( void *args )
{
    struct glVDPAURegisterOutputSurfaceNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVDPAURegisterOutputSurfaceNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glVDPAURegisterOutputSurfaceNV( params->vdpSurface, params->target, params->numTextureNames, params->textureNames );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVDPAURegisterVideoSurfaceNV( void *args )
{
    struct glVDPAURegisterVideoSurfaceNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVDPAURegisterVideoSurfaceNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glVDPAURegisterVideoSurfaceNV( params->vdpSurface, params->target, params->numTextureNames, params->textureNames );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVDPAURegisterVideoSurfaceWithPictureStructureNV( void *args )
{
    struct glVDPAURegisterVideoSurfaceWithPictureStructureNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVDPAURegisterVideoSurfaceWithPictureStructureNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glVDPAURegisterVideoSurfaceWithPictureStructureNV( params->vdpSurface, params->target, params->numTextureNames, params->textureNames, params->isFrameStructure );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVDPAUSurfaceAccessNV( void *args )
{
    struct glVDPAUSurfaceAccessNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVDPAUSurfaceAccessNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVDPAUSurfaceAccessNV( params->surface, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVDPAUUnmapSurfacesNV( void *args )
{
    struct glVDPAUUnmapSurfacesNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVDPAUUnmapSurfacesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVDPAUUnmapSurfacesNV( params->numSurface, params->surfaces );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVDPAUUnregisterSurfaceNV( void *args )
{
    struct glVDPAUUnregisterSurfaceNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVDPAUUnregisterSurfaceNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVDPAUUnregisterSurfaceNV( params->surface );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glValidateProgram( void *args )
{
    struct glValidateProgram_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glValidateProgram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glValidateProgram( params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glValidateProgramARB( void *args )
{
    struct glValidateProgramARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glValidateProgramARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glValidateProgramARB( params->programObj );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glValidateProgramPipeline( void *args )
{
    struct glValidateProgramPipeline_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glValidateProgramPipeline) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glValidateProgramPipeline( params->pipeline );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVariantArrayObjectATI( void *args )
{
    struct glVariantArrayObjectATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVariantArrayObjectATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantArrayObjectATI( params->id, params->type, params->stride, params->buffer, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVariantPointerEXT( void *args )
{
    struct glVariantPointerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVariantPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantPointerEXT( params->id, params->type, params->stride, params->addr );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVariantbvEXT( void *args )
{
    struct glVariantbvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVariantbvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantbvEXT( params->id, params->addr );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVariantdvEXT( void *args )
{
    struct glVariantdvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVariantdvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantdvEXT( params->id, params->addr );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVariantfvEXT( void *args )
{
    struct glVariantfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVariantfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantfvEXT( params->id, params->addr );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVariantivEXT( void *args )
{
    struct glVariantivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVariantivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantivEXT( params->id, params->addr );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVariantsvEXT( void *args )
{
    struct glVariantsvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVariantsvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantsvEXT( params->id, params->addr );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVariantubvEXT( void *args )
{
    struct glVariantubvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVariantubvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantubvEXT( params->id, params->addr );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVariantuivEXT( void *args )
{
    struct glVariantuivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVariantuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantuivEXT( params->id, params->addr );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVariantusvEXT( void *args )
{
    struct glVariantusvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVariantusvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantusvEXT( params->id, params->addr );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex2bOES( void *args )
{
    struct glVertex2bOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex2bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2bOES( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex2bvOES( void *args )
{
    struct glVertex2bvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex2bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2bvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex2hNV( void *args )
{
    struct glVertex2hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex2hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2hNV( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex2hvNV( void *args )
{
    struct glVertex2hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex2hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2hvNV( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex2xOES( void *args )
{
    struct glVertex2xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex2xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2xOES( params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex2xvOES( void *args )
{
    struct glVertex2xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex2xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2xvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex3bOES( void *args )
{
    struct glVertex3bOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex3bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3bOES( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex3bvOES( void *args )
{
    struct glVertex3bvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex3bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3bvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex3hNV( void *args )
{
    struct glVertex3hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex3hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3hNV( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex3hvNV( void *args )
{
    struct glVertex3hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex3hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3hvNV( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex3xOES( void *args )
{
    struct glVertex3xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex3xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3xOES( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex3xvOES( void *args )
{
    struct glVertex3xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex3xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3xvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex4bOES( void *args )
{
    struct glVertex4bOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex4bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4bOES( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex4bvOES( void *args )
{
    struct glVertex4bvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex4bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4bvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex4hNV( void *args )
{
    struct glVertex4hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex4hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4hNV( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex4hvNV( void *args )
{
    struct glVertex4hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex4hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4hvNV( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex4xOES( void *args )
{
    struct glVertex4xOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex4xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4xOES( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertex4xvOES( void *args )
{
    struct glVertex4xvOES_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertex4xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4xvOES( params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayAttribBinding( void *args )
{
    struct glVertexArrayAttribBinding_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayAttribBinding) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayAttribBinding( params->vaobj, params->attribindex, params->bindingindex );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayAttribFormat( void *args )
{
    struct glVertexArrayAttribFormat_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayAttribFormat) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayAttribFormat( params->vaobj, params->attribindex, params->size, params->type, params->normalized, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayAttribIFormat( void *args )
{
    struct glVertexArrayAttribIFormat_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayAttribIFormat) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayAttribIFormat( params->vaobj, params->attribindex, params->size, params->type, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayAttribLFormat( void *args )
{
    struct glVertexArrayAttribLFormat_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayAttribLFormat) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayAttribLFormat( params->vaobj, params->attribindex, params->size, params->type, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayBindVertexBufferEXT( void *args )
{
    struct glVertexArrayBindVertexBufferEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayBindVertexBufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayBindVertexBufferEXT( params->vaobj, params->bindingindex, params->buffer, params->offset, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayBindingDivisor( void *args )
{
    struct glVertexArrayBindingDivisor_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayBindingDivisor) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayBindingDivisor( params->vaobj, params->bindingindex, params->divisor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayColorOffsetEXT( void *args )
{
    struct glVertexArrayColorOffsetEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayColorOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayColorOffsetEXT( params->vaobj, params->buffer, params->size, params->type, params->stride, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayEdgeFlagOffsetEXT( void *args )
{
    struct glVertexArrayEdgeFlagOffsetEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayEdgeFlagOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayEdgeFlagOffsetEXT( params->vaobj, params->buffer, params->stride, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayElementBuffer( void *args )
{
    struct glVertexArrayElementBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayElementBuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayElementBuffer( params->vaobj, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayFogCoordOffsetEXT( void *args )
{
    struct glVertexArrayFogCoordOffsetEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayFogCoordOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayFogCoordOffsetEXT( params->vaobj, params->buffer, params->type, params->stride, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayIndexOffsetEXT( void *args )
{
    struct glVertexArrayIndexOffsetEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayIndexOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayIndexOffsetEXT( params->vaobj, params->buffer, params->type, params->stride, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayMultiTexCoordOffsetEXT( void *args )
{
    struct glVertexArrayMultiTexCoordOffsetEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayMultiTexCoordOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayMultiTexCoordOffsetEXT( params->vaobj, params->buffer, params->texunit, params->size, params->type, params->stride, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayNormalOffsetEXT( void *args )
{
    struct glVertexArrayNormalOffsetEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayNormalOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayNormalOffsetEXT( params->vaobj, params->buffer, params->type, params->stride, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayParameteriAPPLE( void *args )
{
    struct glVertexArrayParameteriAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayParameteriAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayParameteriAPPLE( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayRangeAPPLE( void *args )
{
    struct glVertexArrayRangeAPPLE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayRangeAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayRangeAPPLE( params->length, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayRangeNV( void *args )
{
    struct glVertexArrayRangeNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayRangeNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayRangeNV( params->length, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArraySecondaryColorOffsetEXT( void *args )
{
    struct glVertexArraySecondaryColorOffsetEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArraySecondaryColorOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArraySecondaryColorOffsetEXT( params->vaobj, params->buffer, params->size, params->type, params->stride, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayTexCoordOffsetEXT( void *args )
{
    struct glVertexArrayTexCoordOffsetEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayTexCoordOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayTexCoordOffsetEXT( params->vaobj, params->buffer, params->size, params->type, params->stride, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayVertexAttribBindingEXT( void *args )
{
    struct glVertexArrayVertexAttribBindingEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayVertexAttribBindingEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexAttribBindingEXT( params->vaobj, params->attribindex, params->bindingindex );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayVertexAttribDivisorEXT( void *args )
{
    struct glVertexArrayVertexAttribDivisorEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayVertexAttribDivisorEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexAttribDivisorEXT( params->vaobj, params->index, params->divisor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayVertexAttribFormatEXT( void *args )
{
    struct glVertexArrayVertexAttribFormatEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayVertexAttribFormatEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexAttribFormatEXT( params->vaobj, params->attribindex, params->size, params->type, params->normalized, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayVertexAttribIFormatEXT( void *args )
{
    struct glVertexArrayVertexAttribIFormatEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayVertexAttribIFormatEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexAttribIFormatEXT( params->vaobj, params->attribindex, params->size, params->type, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayVertexAttribIOffsetEXT( void *args )
{
    struct glVertexArrayVertexAttribIOffsetEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayVertexAttribIOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexAttribIOffsetEXT( params->vaobj, params->buffer, params->index, params->size, params->type, params->stride, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayVertexAttribLFormatEXT( void *args )
{
    struct glVertexArrayVertexAttribLFormatEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayVertexAttribLFormatEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexAttribLFormatEXT( params->vaobj, params->attribindex, params->size, params->type, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayVertexAttribLOffsetEXT( void *args )
{
    struct glVertexArrayVertexAttribLOffsetEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayVertexAttribLOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexAttribLOffsetEXT( params->vaobj, params->buffer, params->index, params->size, params->type, params->stride, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayVertexAttribOffsetEXT( void *args )
{
    struct glVertexArrayVertexAttribOffsetEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayVertexAttribOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexAttribOffsetEXT( params->vaobj, params->buffer, params->index, params->size, params->type, params->normalized, params->stride, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayVertexBindingDivisorEXT( void *args )
{
    struct glVertexArrayVertexBindingDivisorEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayVertexBindingDivisorEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexBindingDivisorEXT( params->vaobj, params->bindingindex, params->divisor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayVertexBuffer( void *args )
{
    struct glVertexArrayVertexBuffer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayVertexBuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexBuffer( params->vaobj, params->bindingindex, params->buffer, params->offset, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayVertexBuffers( void *args )
{
    struct glVertexArrayVertexBuffers_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayVertexBuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexBuffers( params->vaobj, params->first, params->count, params->buffers, params->offsets, params->strides );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexArrayVertexOffsetEXT( void *args )
{
    struct glVertexArrayVertexOffsetEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexArrayVertexOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexOffsetEXT( params->vaobj, params->buffer, params->size, params->type, params->stride, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1d( void *args )
{
    struct glVertexAttrib1d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1d( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1dARB( void *args )
{
    struct glVertexAttrib1dARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1dARB( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1dNV( void *args )
{
    struct glVertexAttrib1dNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1dNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1dNV( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1dv( void *args )
{
    struct glVertexAttrib1dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1dv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1dvARB( void *args )
{
    struct glVertexAttrib1dvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1dvARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1dvNV( void *args )
{
    struct glVertexAttrib1dvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1dvNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1f( void *args )
{
    struct glVertexAttrib1f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1f( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1fARB( void *args )
{
    struct glVertexAttrib1fARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1fARB( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1fNV( void *args )
{
    struct glVertexAttrib1fNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1fNV( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1fv( void *args )
{
    struct glVertexAttrib1fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1fv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1fvARB( void *args )
{
    struct glVertexAttrib1fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1fvARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1fvNV( void *args )
{
    struct glVertexAttrib1fvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1fvNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1hNV( void *args )
{
    struct glVertexAttrib1hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1hNV( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1hvNV( void *args )
{
    struct glVertexAttrib1hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1hvNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1s( void *args )
{
    struct glVertexAttrib1s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1s( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1sARB( void *args )
{
    struct glVertexAttrib1sARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1sARB( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1sNV( void *args )
{
    struct glVertexAttrib1sNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1sNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1sNV( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1sv( void *args )
{
    struct glVertexAttrib1sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1sv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1svARB( void *args )
{
    struct glVertexAttrib1svARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1svARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib1svNV( void *args )
{
    struct glVertexAttrib1svNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib1svNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1svNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2d( void *args )
{
    struct glVertexAttrib2d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2d( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2dARB( void *args )
{
    struct glVertexAttrib2dARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2dARB( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2dNV( void *args )
{
    struct glVertexAttrib2dNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2dNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2dNV( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2dv( void *args )
{
    struct glVertexAttrib2dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2dv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2dvARB( void *args )
{
    struct glVertexAttrib2dvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2dvARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2dvNV( void *args )
{
    struct glVertexAttrib2dvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2dvNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2f( void *args )
{
    struct glVertexAttrib2f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2f( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2fARB( void *args )
{
    struct glVertexAttrib2fARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2fARB( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2fNV( void *args )
{
    struct glVertexAttrib2fNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2fNV( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2fv( void *args )
{
    struct glVertexAttrib2fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2fv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2fvARB( void *args )
{
    struct glVertexAttrib2fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2fvARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2fvNV( void *args )
{
    struct glVertexAttrib2fvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2fvNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2hNV( void *args )
{
    struct glVertexAttrib2hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2hNV( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2hvNV( void *args )
{
    struct glVertexAttrib2hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2hvNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2s( void *args )
{
    struct glVertexAttrib2s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2s( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2sARB( void *args )
{
    struct glVertexAttrib2sARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2sARB( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2sNV( void *args )
{
    struct glVertexAttrib2sNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2sNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2sNV( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2sv( void *args )
{
    struct glVertexAttrib2sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2sv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2svARB( void *args )
{
    struct glVertexAttrib2svARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2svARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib2svNV( void *args )
{
    struct glVertexAttrib2svNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib2svNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2svNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3d( void *args )
{
    struct glVertexAttrib3d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3d( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3dARB( void *args )
{
    struct glVertexAttrib3dARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3dARB( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3dNV( void *args )
{
    struct glVertexAttrib3dNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3dNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3dNV( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3dv( void *args )
{
    struct glVertexAttrib3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3dv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3dvARB( void *args )
{
    struct glVertexAttrib3dvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3dvARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3dvNV( void *args )
{
    struct glVertexAttrib3dvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3dvNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3f( void *args )
{
    struct glVertexAttrib3f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3f( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3fARB( void *args )
{
    struct glVertexAttrib3fARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3fARB( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3fNV( void *args )
{
    struct glVertexAttrib3fNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3fNV( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3fv( void *args )
{
    struct glVertexAttrib3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3fv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3fvARB( void *args )
{
    struct glVertexAttrib3fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3fvARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3fvNV( void *args )
{
    struct glVertexAttrib3fvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3fvNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3hNV( void *args )
{
    struct glVertexAttrib3hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3hNV( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3hvNV( void *args )
{
    struct glVertexAttrib3hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3hvNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3s( void *args )
{
    struct glVertexAttrib3s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3s( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3sARB( void *args )
{
    struct glVertexAttrib3sARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3sARB( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3sNV( void *args )
{
    struct glVertexAttrib3sNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3sNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3sNV( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3sv( void *args )
{
    struct glVertexAttrib3sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3sv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3svARB( void *args )
{
    struct glVertexAttrib3svARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3svARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib3svNV( void *args )
{
    struct glVertexAttrib3svNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib3svNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3svNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4Nbv( void *args )
{
    struct glVertexAttrib4Nbv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4Nbv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4Nbv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4NbvARB( void *args )
{
    struct glVertexAttrib4NbvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4NbvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4NbvARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4Niv( void *args )
{
    struct glVertexAttrib4Niv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4Niv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4Niv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4NivARB( void *args )
{
    struct glVertexAttrib4NivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4NivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4NivARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4Nsv( void *args )
{
    struct glVertexAttrib4Nsv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4Nsv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4Nsv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4NsvARB( void *args )
{
    struct glVertexAttrib4NsvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4NsvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4NsvARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4Nub( void *args )
{
    struct glVertexAttrib4Nub_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4Nub) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4Nub( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4NubARB( void *args )
{
    struct glVertexAttrib4NubARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4NubARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4NubARB( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4Nubv( void *args )
{
    struct glVertexAttrib4Nubv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4Nubv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4Nubv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4NubvARB( void *args )
{
    struct glVertexAttrib4NubvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4NubvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4NubvARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4Nuiv( void *args )
{
    struct glVertexAttrib4Nuiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4Nuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4Nuiv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4NuivARB( void *args )
{
    struct glVertexAttrib4NuivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4NuivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4NuivARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4Nusv( void *args )
{
    struct glVertexAttrib4Nusv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4Nusv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4Nusv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4NusvARB( void *args )
{
    struct glVertexAttrib4NusvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4NusvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4NusvARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4bv( void *args )
{
    struct glVertexAttrib4bv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4bv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4bv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4bvARB( void *args )
{
    struct glVertexAttrib4bvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4bvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4bvARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4d( void *args )
{
    struct glVertexAttrib4d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4d( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4dARB( void *args )
{
    struct glVertexAttrib4dARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4dARB( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4dNV( void *args )
{
    struct glVertexAttrib4dNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4dNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4dNV( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4dv( void *args )
{
    struct glVertexAttrib4dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4dv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4dvARB( void *args )
{
    struct glVertexAttrib4dvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4dvARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4dvNV( void *args )
{
    struct glVertexAttrib4dvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4dvNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4f( void *args )
{
    struct glVertexAttrib4f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4f( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4fARB( void *args )
{
    struct glVertexAttrib4fARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4fARB( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4fNV( void *args )
{
    struct glVertexAttrib4fNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4fNV( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4fv( void *args )
{
    struct glVertexAttrib4fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4fv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4fvARB( void *args )
{
    struct glVertexAttrib4fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4fvARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4fvNV( void *args )
{
    struct glVertexAttrib4fvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4fvNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4hNV( void *args )
{
    struct glVertexAttrib4hNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4hNV( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4hvNV( void *args )
{
    struct glVertexAttrib4hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4hvNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4iv( void *args )
{
    struct glVertexAttrib4iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4iv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4ivARB( void *args )
{
    struct glVertexAttrib4ivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4ivARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4s( void *args )
{
    struct glVertexAttrib4s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4s( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4sARB( void *args )
{
    struct glVertexAttrib4sARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4sARB( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4sNV( void *args )
{
    struct glVertexAttrib4sNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4sNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4sNV( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4sv( void *args )
{
    struct glVertexAttrib4sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4sv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4svARB( void *args )
{
    struct glVertexAttrib4svARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4svARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4svNV( void *args )
{
    struct glVertexAttrib4svNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4svNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4svNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4ubNV( void *args )
{
    struct glVertexAttrib4ubNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4ubNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4ubNV( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4ubv( void *args )
{
    struct glVertexAttrib4ubv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4ubv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4ubv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4ubvARB( void *args )
{
    struct glVertexAttrib4ubvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4ubvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4ubvARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4ubvNV( void *args )
{
    struct glVertexAttrib4ubvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4ubvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4ubvNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4uiv( void *args )
{
    struct glVertexAttrib4uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4uiv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4uivARB( void *args )
{
    struct glVertexAttrib4uivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4uivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4uivARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4usv( void *args )
{
    struct glVertexAttrib4usv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4usv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4usv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttrib4usvARB( void *args )
{
    struct glVertexAttrib4usvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttrib4usvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4usvARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribArrayObjectATI( void *args )
{
    struct glVertexAttribArrayObjectATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribArrayObjectATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribArrayObjectATI( params->index, params->size, params->type, params->normalized, params->stride, params->buffer, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribBinding( void *args )
{
    struct glVertexAttribBinding_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribBinding) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribBinding( params->attribindex, params->bindingindex );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribDivisor( void *args )
{
    struct glVertexAttribDivisor_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribDivisor) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribDivisor( params->index, params->divisor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribDivisorARB( void *args )
{
    struct glVertexAttribDivisorARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribDivisorARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribDivisorARB( params->index, params->divisor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribFormat( void *args )
{
    struct glVertexAttribFormat_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribFormat) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribFormat( params->attribindex, params->size, params->type, params->normalized, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribFormatNV( void *args )
{
    struct glVertexAttribFormatNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribFormatNV( params->index, params->size, params->type, params->normalized, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI1i( void *args )
{
    struct glVertexAttribI1i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI1i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI1i( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI1iEXT( void *args )
{
    struct glVertexAttribI1iEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI1iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI1iEXT( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI1iv( void *args )
{
    struct glVertexAttribI1iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI1iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI1iv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI1ivEXT( void *args )
{
    struct glVertexAttribI1ivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI1ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI1ivEXT( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI1ui( void *args )
{
    struct glVertexAttribI1ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI1ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI1ui( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI1uiEXT( void *args )
{
    struct glVertexAttribI1uiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI1uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI1uiEXT( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI1uiv( void *args )
{
    struct glVertexAttribI1uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI1uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI1uiv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI1uivEXT( void *args )
{
    struct glVertexAttribI1uivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI1uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI1uivEXT( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI2i( void *args )
{
    struct glVertexAttribI2i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI2i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI2i( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI2iEXT( void *args )
{
    struct glVertexAttribI2iEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI2iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI2iEXT( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI2iv( void *args )
{
    struct glVertexAttribI2iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI2iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI2iv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI2ivEXT( void *args )
{
    struct glVertexAttribI2ivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI2ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI2ivEXT( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI2ui( void *args )
{
    struct glVertexAttribI2ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI2ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI2ui( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI2uiEXT( void *args )
{
    struct glVertexAttribI2uiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI2uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI2uiEXT( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI2uiv( void *args )
{
    struct glVertexAttribI2uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI2uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI2uiv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI2uivEXT( void *args )
{
    struct glVertexAttribI2uivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI2uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI2uivEXT( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI3i( void *args )
{
    struct glVertexAttribI3i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI3i( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI3iEXT( void *args )
{
    struct glVertexAttribI3iEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI3iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI3iEXT( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI3iv( void *args )
{
    struct glVertexAttribI3iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI3iv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI3ivEXT( void *args )
{
    struct glVertexAttribI3ivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI3ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI3ivEXT( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI3ui( void *args )
{
    struct glVertexAttribI3ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI3ui( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI3uiEXT( void *args )
{
    struct glVertexAttribI3uiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI3uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI3uiEXT( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI3uiv( void *args )
{
    struct glVertexAttribI3uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI3uiv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI3uivEXT( void *args )
{
    struct glVertexAttribI3uivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI3uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI3uivEXT( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI4bv( void *args )
{
    struct glVertexAttribI4bv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI4bv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4bv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI4bvEXT( void *args )
{
    struct glVertexAttribI4bvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI4bvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4bvEXT( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI4i( void *args )
{
    struct glVertexAttribI4i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI4i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4i( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI4iEXT( void *args )
{
    struct glVertexAttribI4iEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI4iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4iEXT( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI4iv( void *args )
{
    struct glVertexAttribI4iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4iv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI4ivEXT( void *args )
{
    struct glVertexAttribI4ivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI4ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4ivEXT( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI4sv( void *args )
{
    struct glVertexAttribI4sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI4sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4sv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI4svEXT( void *args )
{
    struct glVertexAttribI4svEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI4svEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4svEXT( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI4ubv( void *args )
{
    struct glVertexAttribI4ubv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI4ubv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4ubv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI4ubvEXT( void *args )
{
    struct glVertexAttribI4ubvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI4ubvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4ubvEXT( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI4ui( void *args )
{
    struct glVertexAttribI4ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4ui( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI4uiEXT( void *args )
{
    struct glVertexAttribI4uiEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI4uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4uiEXT( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI4uiv( void *args )
{
    struct glVertexAttribI4uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4uiv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI4uivEXT( void *args )
{
    struct glVertexAttribI4uivEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI4uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4uivEXT( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI4usv( void *args )
{
    struct glVertexAttribI4usv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI4usv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4usv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribI4usvEXT( void *args )
{
    struct glVertexAttribI4usvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribI4usvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4usvEXT( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribIFormat( void *args )
{
    struct glVertexAttribIFormat_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribIFormat) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribIFormat( params->attribindex, params->size, params->type, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribIFormatNV( void *args )
{
    struct glVertexAttribIFormatNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribIFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribIFormatNV( params->index, params->size, params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribIPointer( void *args )
{
    struct glVertexAttribIPointer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribIPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribIPointer( params->index, params->size, params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribIPointerEXT( void *args )
{
    struct glVertexAttribIPointerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribIPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribIPointerEXT( params->index, params->size, params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL1d( void *args )
{
    struct glVertexAttribL1d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1d( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL1dEXT( void *args )
{
    struct glVertexAttribL1dEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL1dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1dEXT( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL1dv( void *args )
{
    struct glVertexAttribL1dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL1dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1dv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL1dvEXT( void *args )
{
    struct glVertexAttribL1dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL1dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1dvEXT( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL1i64NV( void *args )
{
    struct glVertexAttribL1i64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL1i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1i64NV( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL1i64vNV( void *args )
{
    struct glVertexAttribL1i64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL1i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1i64vNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL1ui64ARB( void *args )
{
    struct glVertexAttribL1ui64ARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL1ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1ui64ARB( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL1ui64NV( void *args )
{
    struct glVertexAttribL1ui64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL1ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1ui64NV( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL1ui64vARB( void *args )
{
    struct glVertexAttribL1ui64vARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL1ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1ui64vARB( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL1ui64vNV( void *args )
{
    struct glVertexAttribL1ui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL1ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1ui64vNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL2d( void *args )
{
    struct glVertexAttribL2d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL2d( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL2dEXT( void *args )
{
    struct glVertexAttribL2dEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL2dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL2dEXT( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL2dv( void *args )
{
    struct glVertexAttribL2dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL2dv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL2dvEXT( void *args )
{
    struct glVertexAttribL2dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL2dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL2dvEXT( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL2i64NV( void *args )
{
    struct glVertexAttribL2i64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL2i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL2i64NV( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL2i64vNV( void *args )
{
    struct glVertexAttribL2i64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL2i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL2i64vNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL2ui64NV( void *args )
{
    struct glVertexAttribL2ui64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL2ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL2ui64NV( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL2ui64vNV( void *args )
{
    struct glVertexAttribL2ui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL2ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL2ui64vNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL3d( void *args )
{
    struct glVertexAttribL3d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL3d( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL3dEXT( void *args )
{
    struct glVertexAttribL3dEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL3dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL3dEXT( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL3dv( void *args )
{
    struct glVertexAttribL3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL3dv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL3dvEXT( void *args )
{
    struct glVertexAttribL3dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL3dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL3dvEXT( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL3i64NV( void *args )
{
    struct glVertexAttribL3i64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL3i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL3i64NV( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL3i64vNV( void *args )
{
    struct glVertexAttribL3i64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL3i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL3i64vNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL3ui64NV( void *args )
{
    struct glVertexAttribL3ui64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL3ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL3ui64NV( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL3ui64vNV( void *args )
{
    struct glVertexAttribL3ui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL3ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL3ui64vNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL4d( void *args )
{
    struct glVertexAttribL4d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL4d( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL4dEXT( void *args )
{
    struct glVertexAttribL4dEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL4dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL4dEXT( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL4dv( void *args )
{
    struct glVertexAttribL4dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL4dv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL4dvEXT( void *args )
{
    struct glVertexAttribL4dvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL4dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL4dvEXT( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL4i64NV( void *args )
{
    struct glVertexAttribL4i64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL4i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL4i64NV( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL4i64vNV( void *args )
{
    struct glVertexAttribL4i64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL4i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL4i64vNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL4ui64NV( void *args )
{
    struct glVertexAttribL4ui64NV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL4ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL4ui64NV( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribL4ui64vNV( void *args )
{
    struct glVertexAttribL4ui64vNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribL4ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL4ui64vNV( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribLFormat( void *args )
{
    struct glVertexAttribLFormat_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribLFormat) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribLFormat( params->attribindex, params->size, params->type, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribLFormatNV( void *args )
{
    struct glVertexAttribLFormatNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribLFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribLFormatNV( params->index, params->size, params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribLPointer( void *args )
{
    struct glVertexAttribLPointer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribLPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribLPointer( params->index, params->size, params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribLPointerEXT( void *args )
{
    struct glVertexAttribLPointerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribLPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribLPointerEXT( params->index, params->size, params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribP1ui( void *args )
{
    struct glVertexAttribP1ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribP1ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribP1ui( params->index, params->type, params->normalized, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribP1uiv( void *args )
{
    struct glVertexAttribP1uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribP1uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribP1uiv( params->index, params->type, params->normalized, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribP2ui( void *args )
{
    struct glVertexAttribP2ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribP2ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribP2ui( params->index, params->type, params->normalized, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribP2uiv( void *args )
{
    struct glVertexAttribP2uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribP2uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribP2uiv( params->index, params->type, params->normalized, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribP3ui( void *args )
{
    struct glVertexAttribP3ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribP3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribP3ui( params->index, params->type, params->normalized, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribP3uiv( void *args )
{
    struct glVertexAttribP3uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribP3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribP3uiv( params->index, params->type, params->normalized, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribP4ui( void *args )
{
    struct glVertexAttribP4ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribP4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribP4ui( params->index, params->type, params->normalized, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribP4uiv( void *args )
{
    struct glVertexAttribP4uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribP4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribP4uiv( params->index, params->type, params->normalized, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribParameteriAMD( void *args )
{
    struct glVertexAttribParameteriAMD_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribParameteriAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribParameteriAMD( params->index, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribPointer( void *args )
{
    struct glVertexAttribPointer_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribPointer( params->index, params->size, params->type, params->normalized, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribPointerARB( void *args )
{
    struct glVertexAttribPointerARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribPointerARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribPointerARB( params->index, params->size, params->type, params->normalized, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribPointerNV( void *args )
{
    struct glVertexAttribPointerNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribPointerNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribPointerNV( params->index, params->fsize, params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs1dvNV( void *args )
{
    struct glVertexAttribs1dvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs1dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs1dvNV( params->index, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs1fvNV( void *args )
{
    struct glVertexAttribs1fvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs1fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs1fvNV( params->index, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs1hvNV( void *args )
{
    struct glVertexAttribs1hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs1hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs1hvNV( params->index, params->n, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs1svNV( void *args )
{
    struct glVertexAttribs1svNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs1svNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs1svNV( params->index, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs2dvNV( void *args )
{
    struct glVertexAttribs2dvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs2dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs2dvNV( params->index, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs2fvNV( void *args )
{
    struct glVertexAttribs2fvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs2fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs2fvNV( params->index, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs2hvNV( void *args )
{
    struct glVertexAttribs2hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs2hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs2hvNV( params->index, params->n, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs2svNV( void *args )
{
    struct glVertexAttribs2svNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs2svNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs2svNV( params->index, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs3dvNV( void *args )
{
    struct glVertexAttribs3dvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs3dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs3dvNV( params->index, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs3fvNV( void *args )
{
    struct glVertexAttribs3fvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs3fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs3fvNV( params->index, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs3hvNV( void *args )
{
    struct glVertexAttribs3hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs3hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs3hvNV( params->index, params->n, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs3svNV( void *args )
{
    struct glVertexAttribs3svNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs3svNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs3svNV( params->index, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs4dvNV( void *args )
{
    struct glVertexAttribs4dvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs4dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs4dvNV( params->index, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs4fvNV( void *args )
{
    struct glVertexAttribs4fvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs4fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs4fvNV( params->index, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs4hvNV( void *args )
{
    struct glVertexAttribs4hvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs4hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs4hvNV( params->index, params->n, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs4svNV( void *args )
{
    struct glVertexAttribs4svNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs4svNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs4svNV( params->index, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexAttribs4ubvNV( void *args )
{
    struct glVertexAttribs4ubvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexAttribs4ubvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs4ubvNV( params->index, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexBindingDivisor( void *args )
{
    struct glVertexBindingDivisor_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexBindingDivisor) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexBindingDivisor( params->bindingindex, params->divisor );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexBlendARB( void *args )
{
    struct glVertexBlendARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexBlendARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexBlendARB( params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexBlendEnvfATI( void *args )
{
    struct glVertexBlendEnvfATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexBlendEnvfATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexBlendEnvfATI( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexBlendEnviATI( void *args )
{
    struct glVertexBlendEnviATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexBlendEnviATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexBlendEnviATI( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexFormatNV( void *args )
{
    struct glVertexFormatNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexFormatNV( params->size, params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexP2ui( void *args )
{
    struct glVertexP2ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexP2ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexP2ui( params->type, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexP2uiv( void *args )
{
    struct glVertexP2uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexP2uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexP2uiv( params->type, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexP3ui( void *args )
{
    struct glVertexP3ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexP3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexP3ui( params->type, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexP3uiv( void *args )
{
    struct glVertexP3uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexP3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexP3uiv( params->type, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexP4ui( void *args )
{
    struct glVertexP4ui_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexP4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexP4ui( params->type, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexP4uiv( void *args )
{
    struct glVertexP4uiv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexP4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexP4uiv( params->type, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexPointerEXT( void *args )
{
    struct glVertexPointerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexPointerEXT( params->size, params->type, params->stride, params->count, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexPointerListIBM( void *args )
{
    struct glVertexPointerListIBM_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexPointerListIBM) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexPointerListIBM( params->size, params->type, params->stride, params->pointer, params->ptrstride );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexPointervINTEL( void *args )
{
    struct glVertexPointervINTEL_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexPointervINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexPointervINTEL( params->size, params->type, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream1dATI( void *args )
{
    struct glVertexStream1dATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream1dATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream1dATI( params->stream, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream1dvATI( void *args )
{
    struct glVertexStream1dvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream1dvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream1dvATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream1fATI( void *args )
{
    struct glVertexStream1fATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream1fATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream1fATI( params->stream, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream1fvATI( void *args )
{
    struct glVertexStream1fvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream1fvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream1fvATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream1iATI( void *args )
{
    struct glVertexStream1iATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream1iATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream1iATI( params->stream, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream1ivATI( void *args )
{
    struct glVertexStream1ivATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream1ivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream1ivATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream1sATI( void *args )
{
    struct glVertexStream1sATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream1sATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream1sATI( params->stream, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream1svATI( void *args )
{
    struct glVertexStream1svATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream1svATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream1svATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream2dATI( void *args )
{
    struct glVertexStream2dATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream2dATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream2dATI( params->stream, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream2dvATI( void *args )
{
    struct glVertexStream2dvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream2dvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream2dvATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream2fATI( void *args )
{
    struct glVertexStream2fATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream2fATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream2fATI( params->stream, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream2fvATI( void *args )
{
    struct glVertexStream2fvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream2fvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream2fvATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream2iATI( void *args )
{
    struct glVertexStream2iATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream2iATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream2iATI( params->stream, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream2ivATI( void *args )
{
    struct glVertexStream2ivATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream2ivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream2ivATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream2sATI( void *args )
{
    struct glVertexStream2sATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream2sATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream2sATI( params->stream, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream2svATI( void *args )
{
    struct glVertexStream2svATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream2svATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream2svATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream3dATI( void *args )
{
    struct glVertexStream3dATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream3dATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream3dATI( params->stream, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream3dvATI( void *args )
{
    struct glVertexStream3dvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream3dvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream3dvATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream3fATI( void *args )
{
    struct glVertexStream3fATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream3fATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream3fATI( params->stream, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream3fvATI( void *args )
{
    struct glVertexStream3fvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream3fvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream3fvATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream3iATI( void *args )
{
    struct glVertexStream3iATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream3iATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream3iATI( params->stream, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream3ivATI( void *args )
{
    struct glVertexStream3ivATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream3ivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream3ivATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream3sATI( void *args )
{
    struct glVertexStream3sATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream3sATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream3sATI( params->stream, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream3svATI( void *args )
{
    struct glVertexStream3svATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream3svATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream3svATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream4dATI( void *args )
{
    struct glVertexStream4dATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream4dATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream4dATI( params->stream, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream4dvATI( void *args )
{
    struct glVertexStream4dvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream4dvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream4dvATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream4fATI( void *args )
{
    struct glVertexStream4fATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream4fATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream4fATI( params->stream, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream4fvATI( void *args )
{
    struct glVertexStream4fvATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream4fvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream4fvATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream4iATI( void *args )
{
    struct glVertexStream4iATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream4iATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream4iATI( params->stream, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream4ivATI( void *args )
{
    struct glVertexStream4ivATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream4ivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream4ivATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream4sATI( void *args )
{
    struct glVertexStream4sATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream4sATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream4sATI( params->stream, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexStream4svATI( void *args )
{
    struct glVertexStream4svATI_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexStream4svATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream4svATI( params->stream, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexWeightPointerEXT( void *args )
{
    struct glVertexWeightPointerEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexWeightPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexWeightPointerEXT( params->size, params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexWeightfEXT( void *args )
{
    struct glVertexWeightfEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexWeightfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexWeightfEXT( params->weight );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexWeightfvEXT( void *args )
{
    struct glVertexWeightfvEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexWeightfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexWeightfvEXT( params->weight );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexWeighthNV( void *args )
{
    struct glVertexWeighthNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexWeighthNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexWeighthNV( params->weight );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVertexWeighthvNV( void *args )
{
    struct glVertexWeighthvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVertexWeighthvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexWeighthvNV( params->weight );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVideoCaptureNV( void *args )
{
    struct glVideoCaptureNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVideoCaptureNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glVideoCaptureNV( params->video_capture_slot, params->sequence_num, params->capture_time );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVideoCaptureStreamParameterdvNV( void *args )
{
    struct glVideoCaptureStreamParameterdvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVideoCaptureStreamParameterdvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVideoCaptureStreamParameterdvNV( params->video_capture_slot, params->stream, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVideoCaptureStreamParameterfvNV( void *args )
{
    struct glVideoCaptureStreamParameterfvNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVideoCaptureStreamParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVideoCaptureStreamParameterfvNV( params->video_capture_slot, params->stream, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glVideoCaptureStreamParameterivNV( void *args )
{
    struct glVideoCaptureStreamParameterivNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glVideoCaptureStreamParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVideoCaptureStreamParameterivNV( params->video_capture_slot, params->stream, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glViewportArrayv( void *args )
{
    struct glViewportArrayv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glViewportArrayv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glViewportArrayv( params->first, params->count, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glViewportIndexedf( void *args )
{
    struct glViewportIndexedf_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glViewportIndexedf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glViewportIndexedf( params->index, params->x, params->y, params->w, params->h );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glViewportIndexedfv( void *args )
{
    struct glViewportIndexedfv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glViewportIndexedfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glViewportIndexedfv( params->index, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glViewportPositionWScaleNV( void *args )
{
    struct glViewportPositionWScaleNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glViewportPositionWScaleNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glViewportPositionWScaleNV( params->index, params->xcoeff, params->ycoeff );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glViewportSwizzleNV( void *args )
{
    struct glViewportSwizzleNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glViewportSwizzleNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glViewportSwizzleNV( params->index, params->swizzlex, params->swizzley, params->swizzlez, params->swizzlew );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWaitSemaphoreEXT( void *args )
{
    struct glWaitSemaphoreEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWaitSemaphoreEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWaitSemaphoreEXT( params->semaphore, params->numBufferBarriers, params->buffers, params->numTextureBarriers, params->textures, params->srcLayouts );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWaitSemaphoreui64NVX( void *args )
{
    struct glWaitSemaphoreui64NVX_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWaitSemaphoreui64NVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWaitSemaphoreui64NVX( params->waitGpu, params->fenceObjectCount, params->semaphoreArray, params->fenceValueArray );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWaitSync( void *args )
{
    struct glWaitSync_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWaitSync) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWaitSync( get_unix_sync( params->sync ), params->flags, params->timeout );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWaitVkSemaphoreNV( void *args )
{
    struct glWaitVkSemaphoreNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWaitVkSemaphoreNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWaitVkSemaphoreNV( params->vkSemaphore );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWeightPathsNV( void *args )
{
    struct glWeightPathsNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWeightPathsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightPathsNV( params->resultPath, params->numPaths, params->paths, params->weights );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWeightPointerARB( void *args )
{
    struct glWeightPointerARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWeightPointerARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightPointerARB( params->size, params->type, params->stride, params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWeightbvARB( void *args )
{
    struct glWeightbvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWeightbvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightbvARB( params->size, params->weights );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWeightdvARB( void *args )
{
    struct glWeightdvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWeightdvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightdvARB( params->size, params->weights );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWeightfvARB( void *args )
{
    struct glWeightfvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWeightfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightfvARB( params->size, params->weights );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWeightivARB( void *args )
{
    struct glWeightivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWeightivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightivARB( params->size, params->weights );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWeightsvARB( void *args )
{
    struct glWeightsvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWeightsvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightsvARB( params->size, params->weights );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWeightubvARB( void *args )
{
    struct glWeightubvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWeightubvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightubvARB( params->size, params->weights );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWeightuivARB( void *args )
{
    struct glWeightuivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWeightuivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightuivARB( params->size, params->weights );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWeightusvARB( void *args )
{
    struct glWeightusvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWeightusvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightusvARB( params->size, params->weights );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2d( void *args )
{
    struct glWindowPos2d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2d( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2dARB( void *args )
{
    struct glWindowPos2dARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2dARB( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2dMESA( void *args )
{
    struct glWindowPos2dMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2dMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2dMESA( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2dv( void *args )
{
    struct glWindowPos2dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2dv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2dvARB( void *args )
{
    struct glWindowPos2dvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2dvARB( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2dvMESA( void *args )
{
    struct glWindowPos2dvMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2dvMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2dvMESA( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2f( void *args )
{
    struct glWindowPos2f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2f( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2fARB( void *args )
{
    struct glWindowPos2fARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2fARB( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2fMESA( void *args )
{
    struct glWindowPos2fMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2fMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2fMESA( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2fv( void *args )
{
    struct glWindowPos2fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2fv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2fvARB( void *args )
{
    struct glWindowPos2fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2fvARB( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2fvMESA( void *args )
{
    struct glWindowPos2fvMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2fvMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2fvMESA( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2i( void *args )
{
    struct glWindowPos2i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2i( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2iARB( void *args )
{
    struct glWindowPos2iARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2iARB( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2iMESA( void *args )
{
    struct glWindowPos2iMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2iMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2iMESA( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2iv( void *args )
{
    struct glWindowPos2iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2iv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2ivARB( void *args )
{
    struct glWindowPos2ivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2ivARB( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2ivMESA( void *args )
{
    struct glWindowPos2ivMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2ivMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2ivMESA( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2s( void *args )
{
    struct glWindowPos2s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2s( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2sARB( void *args )
{
    struct glWindowPos2sARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2sARB( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2sMESA( void *args )
{
    struct glWindowPos2sMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2sMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2sMESA( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2sv( void *args )
{
    struct glWindowPos2sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2sv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2svARB( void *args )
{
    struct glWindowPos2svARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2svARB( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos2svMESA( void *args )
{
    struct glWindowPos2svMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos2svMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2svMESA( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3d( void *args )
{
    struct glWindowPos3d_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3d( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3dARB( void *args )
{
    struct glWindowPos3dARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3dARB( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3dMESA( void *args )
{
    struct glWindowPos3dMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3dMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3dMESA( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3dv( void *args )
{
    struct glWindowPos3dv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3dv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3dvARB( void *args )
{
    struct glWindowPos3dvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3dvARB( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3dvMESA( void *args )
{
    struct glWindowPos3dvMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3dvMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3dvMESA( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3f( void *args )
{
    struct glWindowPos3f_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3f( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3fARB( void *args )
{
    struct glWindowPos3fARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3fARB( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3fMESA( void *args )
{
    struct glWindowPos3fMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3fMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3fMESA( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3fv( void *args )
{
    struct glWindowPos3fv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3fv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3fvARB( void *args )
{
    struct glWindowPos3fvARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3fvARB( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3fvMESA( void *args )
{
    struct glWindowPos3fvMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3fvMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3fvMESA( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3i( void *args )
{
    struct glWindowPos3i_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3i( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3iARB( void *args )
{
    struct glWindowPos3iARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3iARB( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3iMESA( void *args )
{
    struct glWindowPos3iMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3iMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3iMESA( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3iv( void *args )
{
    struct glWindowPos3iv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3iv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3ivARB( void *args )
{
    struct glWindowPos3ivARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3ivARB( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3ivMESA( void *args )
{
    struct glWindowPos3ivMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3ivMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3ivMESA( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3s( void *args )
{
    struct glWindowPos3s_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3s( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3sARB( void *args )
{
    struct glWindowPos3sARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3sARB( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3sMESA( void *args )
{
    struct glWindowPos3sMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3sMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3sMESA( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3sv( void *args )
{
    struct glWindowPos3sv_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3sv( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3svARB( void *args )
{
    struct glWindowPos3svARB_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3svARB( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos3svMESA( void *args )
{
    struct glWindowPos3svMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos3svMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3svMESA( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos4dMESA( void *args )
{
    struct glWindowPos4dMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos4dMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos4dMESA( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos4dvMESA( void *args )
{
    struct glWindowPos4dvMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos4dvMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos4dvMESA( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos4fMESA( void *args )
{
    struct glWindowPos4fMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos4fMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos4fMESA( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos4fvMESA( void *args )
{
    struct glWindowPos4fvMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos4fvMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos4fvMESA( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos4iMESA( void *args )
{
    struct glWindowPos4iMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos4iMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos4iMESA( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos4ivMESA( void *args )
{
    struct glWindowPos4ivMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos4ivMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos4ivMESA( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos4sMESA( void *args )
{
    struct glWindowPos4sMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos4sMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos4sMESA( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowPos4svMESA( void *args )
{
    struct glWindowPos4svMESA_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowPos4svMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos4svMESA( params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWindowRectanglesEXT( void *args )
{
    struct glWindowRectanglesEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWindowRectanglesEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowRectanglesEXT( params->mode, params->count, params->box );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_glWriteMaskEXT( void *args )
{
    struct glWriteMaskEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_glWriteMaskEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWriteMaskEXT( params->res, params->in, params->outX, params->outY, params->outZ, params->outW );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglAllocateMemoryNV( void *args )
{
    struct wglAllocateMemoryNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_wglAllocateMemoryNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglAllocateMemoryNV( params->size, params->readfreq, params->writefreq, params->priority );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglBindTexImageARB( void *args )
{
    struct wglBindTexImageARB_params *params = args;
    const struct opengl_funcs *funcs = get_pbuffer_funcs( params->hPbuffer );
    if (!funcs || !funcs->p_wglBindTexImageARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglBindTexImageARB( params->hPbuffer, params->iBuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglCreateContextAttribsARB( void *args )
{
    struct wglCreateContextAttribsARB_params *params = args;
    params->ret = wrap_wglCreateContextAttribsARB( params->teb, params->hDC, params->hShareContext, params->attribList, params->ret );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglCreatePbufferARB( void *args )
{
    struct wglCreatePbufferARB_params *params = args;
    params->ret = wrap_wglCreatePbufferARB( params->teb, params->hDC, params->iPixelFormat, params->iWidth, params->iHeight, params->piAttribList, params->ret );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglDestroyPbufferARB( void *args )
{
    struct wglDestroyPbufferARB_params *params = args;
    const struct opengl_funcs *funcs = get_pbuffer_funcs( params->hPbuffer );
    if (!funcs || !funcs->p_wglDestroyPbufferARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglDestroyPbufferARB( params->hPbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglFreeMemoryNV( void *args )
{
    struct wglFreeMemoryNV_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_wglFreeMemoryNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_wglFreeMemoryNV( params->pointer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglGetPbufferDCARB( void *args )
{
    struct wglGetPbufferDCARB_params *params = args;
    const struct opengl_funcs *funcs = get_pbuffer_funcs( params->hPbuffer );
    if (!funcs || !funcs->p_wglGetPbufferDCARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglGetPbufferDCARB( params->hPbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglGetSwapIntervalEXT( void *args )
{
    struct wglGetSwapIntervalEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_wglGetSwapIntervalEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglGetSwapIntervalEXT();
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglMakeContextCurrentARB( void *args )
{
    struct wglMakeContextCurrentARB_params *params = args;
    params->ret = wrap_wglMakeContextCurrentARB( params->teb, params->hDrawDC, params->hReadDC, params->hglrc );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglQueryCurrentRendererIntegerWINE( void *args )
{
    struct wglQueryCurrentRendererIntegerWINE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_wglQueryCurrentRendererIntegerWINE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglQueryCurrentRendererIntegerWINE( params->attribute, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglQueryCurrentRendererStringWINE( void *args )
{
    struct wglQueryCurrentRendererStringWINE_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_wglQueryCurrentRendererStringWINE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglQueryCurrentRendererStringWINE( params->attribute );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglQueryPbufferARB( void *args )
{
    struct wglQueryPbufferARB_params *params = args;
    const struct opengl_funcs *funcs = get_pbuffer_funcs( params->hPbuffer );
    if (!funcs || !funcs->p_wglQueryPbufferARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglQueryPbufferARB( params->hPbuffer, params->iAttribute, params->piValue );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglQueryRendererIntegerWINE( void *args )
{
    struct wglQueryRendererIntegerWINE_params *params = args;
    const struct opengl_funcs *funcs = get_dc_funcs( params->dc );
    if (!funcs || !funcs->p_wglQueryRendererIntegerWINE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglQueryRendererIntegerWINE( params->dc, params->renderer, params->attribute, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglQueryRendererStringWINE( void *args )
{
    struct wglQueryRendererStringWINE_params *params = args;
    const struct opengl_funcs *funcs = get_dc_funcs( params->dc );
    if (!funcs || !funcs->p_wglQueryRendererStringWINE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglQueryRendererStringWINE( params->dc, params->renderer, params->attribute );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglReleasePbufferDCARB( void *args )
{
    struct wglReleasePbufferDCARB_params *params = args;
    const struct opengl_funcs *funcs = get_pbuffer_funcs( params->hPbuffer );
    if (!funcs || !funcs->p_wglReleasePbufferDCARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglReleasePbufferDCARB( params->hPbuffer, params->hDC );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglReleaseTexImageARB( void *args )
{
    struct wglReleaseTexImageARB_params *params = args;
    const struct opengl_funcs *funcs = get_pbuffer_funcs( params->hPbuffer );
    if (!funcs || !funcs->p_wglReleaseTexImageARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglReleaseTexImageARB( params->hPbuffer, params->iBuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglSetPbufferAttribARB( void *args )
{
    struct wglSetPbufferAttribARB_params *params = args;
    const struct opengl_funcs *funcs = get_pbuffer_funcs( params->hPbuffer );
    if (!funcs || !funcs->p_wglSetPbufferAttribARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglSetPbufferAttribARB( params->hPbuffer, params->piAttribList );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglSetPixelFormatWINE( void *args )
{
    struct wglSetPixelFormatWINE_params *params = args;
    const struct opengl_funcs *funcs = get_dc_funcs( params->hdc );
    if (!funcs || !funcs->p_wglSetPixelFormatWINE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglSetPixelFormatWINE( params->hdc, params->format );
    return STATUS_SUCCESS;
}

static NTSTATUS ext_wglSwapIntervalEXT( void *args )
{
    struct wglSwapIntervalEXT_params *params = args;
    const struct opengl_funcs *funcs = params->teb->glTable;
    if (!funcs->p_wglSwapIntervalEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglSwapIntervalEXT( params->interval );
    return STATUS_SUCCESS;
}

const unixlib_entry_t __wine_unix_call_funcs[] =
{
    process_attach,
    thread_attach,
    process_detach,
    get_pixel_formats,
    wgl_wglDeleteContext,
    wgl_wglGetPixelFormat,
    wgl_wglSetPixelFormat,
    wgl_wglSwapBuffers,
    gl_glAccum,
    gl_glAlphaFunc,
    gl_glAreTexturesResident,
    gl_glArrayElement,
    gl_glBegin,
    gl_glBindTexture,
    gl_glBitmap,
    gl_glBlendFunc,
    gl_glCallList,
    gl_glCallLists,
    gl_glClear,
    gl_glClearAccum,
    gl_glClearColor,
    gl_glClearDepth,
    gl_glClearIndex,
    gl_glClearStencil,
    gl_glClipPlane,
    gl_glColor3b,
    gl_glColor3bv,
    gl_glColor3d,
    gl_glColor3dv,
    gl_glColor3f,
    gl_glColor3fv,
    gl_glColor3i,
    gl_glColor3iv,
    gl_glColor3s,
    gl_glColor3sv,
    gl_glColor3ub,
    gl_glColor3ubv,
    gl_glColor3ui,
    gl_glColor3uiv,
    gl_glColor3us,
    gl_glColor3usv,
    gl_glColor4b,
    gl_glColor4bv,
    gl_glColor4d,
    gl_glColor4dv,
    gl_glColor4f,
    gl_glColor4fv,
    gl_glColor4i,
    gl_glColor4iv,
    gl_glColor4s,
    gl_glColor4sv,
    gl_glColor4ub,
    gl_glColor4ubv,
    gl_glColor4ui,
    gl_glColor4uiv,
    gl_glColor4us,
    gl_glColor4usv,
    gl_glColorMask,
    gl_glColorMaterial,
    gl_glColorPointer,
    gl_glCopyPixels,
    gl_glCopyTexImage1D,
    gl_glCopyTexImage2D,
    gl_glCopyTexSubImage1D,
    gl_glCopyTexSubImage2D,
    gl_glCullFace,
    gl_glDeleteLists,
    gl_glDeleteTextures,
    gl_glDepthFunc,
    gl_glDepthMask,
    gl_glDepthRange,
    gl_glDisable,
    gl_glDisableClientState,
    gl_glDrawArrays,
    gl_glDrawBuffer,
    gl_glDrawElements,
    gl_glDrawPixels,
    gl_glEdgeFlag,
    gl_glEdgeFlagPointer,
    gl_glEdgeFlagv,
    gl_glEnable,
    gl_glEnableClientState,
    gl_glEnd,
    gl_glEndList,
    gl_glEvalCoord1d,
    gl_glEvalCoord1dv,
    gl_glEvalCoord1f,
    gl_glEvalCoord1fv,
    gl_glEvalCoord2d,
    gl_glEvalCoord2dv,
    gl_glEvalCoord2f,
    gl_glEvalCoord2fv,
    gl_glEvalMesh1,
    gl_glEvalMesh2,
    gl_glEvalPoint1,
    gl_glEvalPoint2,
    gl_glFeedbackBuffer,
    gl_glFinish,
    gl_glFlush,
    gl_glFogf,
    gl_glFogfv,
    gl_glFogi,
    gl_glFogiv,
    gl_glFrontFace,
    gl_glFrustum,
    gl_glGenLists,
    gl_glGenTextures,
    gl_glGetBooleanv,
    gl_glGetClipPlane,
    gl_glGetDoublev,
    gl_glGetError,
    gl_glGetFloatv,
    gl_glGetIntegerv,
    gl_glGetLightfv,
    gl_glGetLightiv,
    gl_glGetMapdv,
    gl_glGetMapfv,
    gl_glGetMapiv,
    gl_glGetMaterialfv,
    gl_glGetMaterialiv,
    gl_glGetPixelMapfv,
    gl_glGetPixelMapuiv,
    gl_glGetPixelMapusv,
    gl_glGetPointerv,
    gl_glGetPolygonStipple,
    gl_glGetString,
    gl_glGetTexEnvfv,
    gl_glGetTexEnviv,
    gl_glGetTexGendv,
    gl_glGetTexGenfv,
    gl_glGetTexGeniv,
    gl_glGetTexImage,
    gl_glGetTexLevelParameterfv,
    gl_glGetTexLevelParameteriv,
    gl_glGetTexParameterfv,
    gl_glGetTexParameteriv,
    gl_glHint,
    gl_glIndexMask,
    gl_glIndexPointer,
    gl_glIndexd,
    gl_glIndexdv,
    gl_glIndexf,
    gl_glIndexfv,
    gl_glIndexi,
    gl_glIndexiv,
    gl_glIndexs,
    gl_glIndexsv,
    gl_glIndexub,
    gl_glIndexubv,
    gl_glInitNames,
    gl_glInterleavedArrays,
    gl_glIsEnabled,
    gl_glIsList,
    gl_glIsTexture,
    gl_glLightModelf,
    gl_glLightModelfv,
    gl_glLightModeli,
    gl_glLightModeliv,
    gl_glLightf,
    gl_glLightfv,
    gl_glLighti,
    gl_glLightiv,
    gl_glLineStipple,
    gl_glLineWidth,
    gl_glListBase,
    gl_glLoadIdentity,
    gl_glLoadMatrixd,
    gl_glLoadMatrixf,
    gl_glLoadName,
    gl_glLogicOp,
    gl_glMap1d,
    gl_glMap1f,
    gl_glMap2d,
    gl_glMap2f,
    gl_glMapGrid1d,
    gl_glMapGrid1f,
    gl_glMapGrid2d,
    gl_glMapGrid2f,
    gl_glMaterialf,
    gl_glMaterialfv,
    gl_glMateriali,
    gl_glMaterialiv,
    gl_glMatrixMode,
    gl_glMultMatrixd,
    gl_glMultMatrixf,
    gl_glNewList,
    gl_glNormal3b,
    gl_glNormal3bv,
    gl_glNormal3d,
    gl_glNormal3dv,
    gl_glNormal3f,
    gl_glNormal3fv,
    gl_glNormal3i,
    gl_glNormal3iv,
    gl_glNormal3s,
    gl_glNormal3sv,
    gl_glNormalPointer,
    gl_glOrtho,
    gl_glPassThrough,
    gl_glPixelMapfv,
    gl_glPixelMapuiv,
    gl_glPixelMapusv,
    gl_glPixelStoref,
    gl_glPixelStorei,
    gl_glPixelTransferf,
    gl_glPixelTransferi,
    gl_glPixelZoom,
    gl_glPointSize,
    gl_glPolygonMode,
    gl_glPolygonOffset,
    gl_glPolygonStipple,
    gl_glPopAttrib,
    gl_glPopClientAttrib,
    gl_glPopMatrix,
    gl_glPopName,
    gl_glPrioritizeTextures,
    gl_glPushAttrib,
    gl_glPushClientAttrib,
    gl_glPushMatrix,
    gl_glPushName,
    gl_glRasterPos2d,
    gl_glRasterPos2dv,
    gl_glRasterPos2f,
    gl_glRasterPos2fv,
    gl_glRasterPos2i,
    gl_glRasterPos2iv,
    gl_glRasterPos2s,
    gl_glRasterPos2sv,
    gl_glRasterPos3d,
    gl_glRasterPos3dv,
    gl_glRasterPos3f,
    gl_glRasterPos3fv,
    gl_glRasterPos3i,
    gl_glRasterPos3iv,
    gl_glRasterPos3s,
    gl_glRasterPos3sv,
    gl_glRasterPos4d,
    gl_glRasterPos4dv,
    gl_glRasterPos4f,
    gl_glRasterPos4fv,
    gl_glRasterPos4i,
    gl_glRasterPos4iv,
    gl_glRasterPos4s,
    gl_glRasterPos4sv,
    gl_glReadBuffer,
    gl_glReadPixels,
    gl_glRectd,
    gl_glRectdv,
    gl_glRectf,
    gl_glRectfv,
    gl_glRecti,
    gl_glRectiv,
    gl_glRects,
    gl_glRectsv,
    gl_glRenderMode,
    gl_glRotated,
    gl_glRotatef,
    gl_glScaled,
    gl_glScalef,
    gl_glScissor,
    gl_glSelectBuffer,
    gl_glShadeModel,
    gl_glStencilFunc,
    gl_glStencilMask,
    gl_glStencilOp,
    gl_glTexCoord1d,
    gl_glTexCoord1dv,
    gl_glTexCoord1f,
    gl_glTexCoord1fv,
    gl_glTexCoord1i,
    gl_glTexCoord1iv,
    gl_glTexCoord1s,
    gl_glTexCoord1sv,
    gl_glTexCoord2d,
    gl_glTexCoord2dv,
    gl_glTexCoord2f,
    gl_glTexCoord2fv,
    gl_glTexCoord2i,
    gl_glTexCoord2iv,
    gl_glTexCoord2s,
    gl_glTexCoord2sv,
    gl_glTexCoord3d,
    gl_glTexCoord3dv,
    gl_glTexCoord3f,
    gl_glTexCoord3fv,
    gl_glTexCoord3i,
    gl_glTexCoord3iv,
    gl_glTexCoord3s,
    gl_glTexCoord3sv,
    gl_glTexCoord4d,
    gl_glTexCoord4dv,
    gl_glTexCoord4f,
    gl_glTexCoord4fv,
    gl_glTexCoord4i,
    gl_glTexCoord4iv,
    gl_glTexCoord4s,
    gl_glTexCoord4sv,
    gl_glTexCoordPointer,
    gl_glTexEnvf,
    gl_glTexEnvfv,
    gl_glTexEnvi,
    gl_glTexEnviv,
    gl_glTexGend,
    gl_glTexGendv,
    gl_glTexGenf,
    gl_glTexGenfv,
    gl_glTexGeni,
    gl_glTexGeniv,
    gl_glTexImage1D,
    gl_glTexImage2D,
    gl_glTexParameterf,
    gl_glTexParameterfv,
    gl_glTexParameteri,
    gl_glTexParameteriv,
    gl_glTexSubImage1D,
    gl_glTexSubImage2D,
    gl_glTranslated,
    gl_glTranslatef,
    gl_glVertex2d,
    gl_glVertex2dv,
    gl_glVertex2f,
    gl_glVertex2fv,
    gl_glVertex2i,
    gl_glVertex2iv,
    gl_glVertex2s,
    gl_glVertex2sv,
    gl_glVertex3d,
    gl_glVertex3dv,
    gl_glVertex3f,
    gl_glVertex3fv,
    gl_glVertex3i,
    gl_glVertex3iv,
    gl_glVertex3s,
    gl_glVertex3sv,
    gl_glVertex4d,
    gl_glVertex4dv,
    gl_glVertex4f,
    gl_glVertex4fv,
    gl_glVertex4i,
    gl_glVertex4iv,
    gl_glVertex4s,
    gl_glVertex4sv,
    gl_glVertexPointer,
    gl_glViewport,
    ext_glAccumxOES,
    ext_glAcquireKeyedMutexWin32EXT,
    ext_glActiveProgramEXT,
    ext_glActiveShaderProgram,
    ext_glActiveStencilFaceEXT,
    ext_glActiveTexture,
    ext_glActiveTextureARB,
    ext_glActiveVaryingNV,
    ext_glAlphaFragmentOp1ATI,
    ext_glAlphaFragmentOp2ATI,
    ext_glAlphaFragmentOp3ATI,
    ext_glAlphaFuncx,
    ext_glAlphaFuncxOES,
    ext_glAlphaToCoverageDitherControlNV,
    ext_glApplyFramebufferAttachmentCMAAINTEL,
    ext_glApplyTextureEXT,
    ext_glAreProgramsResidentNV,
    ext_glAreTexturesResidentEXT,
    ext_glArrayElementEXT,
    ext_glArrayObjectATI,
    ext_glAsyncCopyBufferSubDataNVX,
    ext_glAsyncCopyImageSubDataNVX,
    ext_glAsyncMarkerSGIX,
    ext_glAttachObjectARB,
    ext_glAttachShader,
    ext_glBeginConditionalRender,
    ext_glBeginConditionalRenderNV,
    ext_glBeginConditionalRenderNVX,
    ext_glBeginFragmentShaderATI,
    ext_glBeginOcclusionQueryNV,
    ext_glBeginPerfMonitorAMD,
    ext_glBeginPerfQueryINTEL,
    ext_glBeginQuery,
    ext_glBeginQueryARB,
    ext_glBeginQueryIndexed,
    ext_glBeginTransformFeedback,
    ext_glBeginTransformFeedbackEXT,
    ext_glBeginTransformFeedbackNV,
    ext_glBeginVertexShaderEXT,
    ext_glBeginVideoCaptureNV,
    ext_glBindAttribLocation,
    ext_glBindAttribLocationARB,
    ext_glBindBuffer,
    ext_glBindBufferARB,
    ext_glBindBufferBase,
    ext_glBindBufferBaseEXT,
    ext_glBindBufferBaseNV,
    ext_glBindBufferOffsetEXT,
    ext_glBindBufferOffsetNV,
    ext_glBindBufferRange,
    ext_glBindBufferRangeEXT,
    ext_glBindBufferRangeNV,
    ext_glBindBuffersBase,
    ext_glBindBuffersRange,
    ext_glBindFragDataLocation,
    ext_glBindFragDataLocationEXT,
    ext_glBindFragDataLocationIndexed,
    ext_glBindFragmentShaderATI,
    ext_glBindFramebuffer,
    ext_glBindFramebufferEXT,
    ext_glBindImageTexture,
    ext_glBindImageTextureEXT,
    ext_glBindImageTextures,
    ext_glBindLightParameterEXT,
    ext_glBindMaterialParameterEXT,
    ext_glBindMultiTextureEXT,
    ext_glBindParameterEXT,
    ext_glBindProgramARB,
    ext_glBindProgramNV,
    ext_glBindProgramPipeline,
    ext_glBindRenderbuffer,
    ext_glBindRenderbufferEXT,
    ext_glBindSampler,
    ext_glBindSamplers,
    ext_glBindShadingRateImageNV,
    ext_glBindTexGenParameterEXT,
    ext_glBindTextureEXT,
    ext_glBindTextureUnit,
    ext_glBindTextureUnitParameterEXT,
    ext_glBindTextures,
    ext_glBindTransformFeedback,
    ext_glBindTransformFeedbackNV,
    ext_glBindVertexArray,
    ext_glBindVertexArrayAPPLE,
    ext_glBindVertexBuffer,
    ext_glBindVertexBuffers,
    ext_glBindVertexShaderEXT,
    ext_glBindVideoCaptureStreamBufferNV,
    ext_glBindVideoCaptureStreamTextureNV,
    ext_glBinormal3bEXT,
    ext_glBinormal3bvEXT,
    ext_glBinormal3dEXT,
    ext_glBinormal3dvEXT,
    ext_glBinormal3fEXT,
    ext_glBinormal3fvEXT,
    ext_glBinormal3iEXT,
    ext_glBinormal3ivEXT,
    ext_glBinormal3sEXT,
    ext_glBinormal3svEXT,
    ext_glBinormalPointerEXT,
    ext_glBitmapxOES,
    ext_glBlendBarrier,
    ext_glBlendBarrierKHR,
    ext_glBlendBarrierNV,
    ext_glBlendColor,
    ext_glBlendColorEXT,
    ext_glBlendColorxOES,
    ext_glBlendEquation,
    ext_glBlendEquationEXT,
    ext_glBlendEquationIndexedAMD,
    ext_glBlendEquationSeparate,
    ext_glBlendEquationSeparateEXT,
    ext_glBlendEquationSeparateIndexedAMD,
    ext_glBlendEquationSeparatei,
    ext_glBlendEquationSeparateiARB,
    ext_glBlendEquationi,
    ext_glBlendEquationiARB,
    ext_glBlendFuncIndexedAMD,
    ext_glBlendFuncSeparate,
    ext_glBlendFuncSeparateEXT,
    ext_glBlendFuncSeparateINGR,
    ext_glBlendFuncSeparateIndexedAMD,
    ext_glBlendFuncSeparatei,
    ext_glBlendFuncSeparateiARB,
    ext_glBlendFunci,
    ext_glBlendFunciARB,
    ext_glBlendParameteriNV,
    ext_glBlitFramebuffer,
    ext_glBlitFramebufferEXT,
    ext_glBlitFramebufferLayerEXT,
    ext_glBlitFramebufferLayersEXT,
    ext_glBlitNamedFramebuffer,
    ext_glBufferAddressRangeNV,
    ext_glBufferAttachMemoryNV,
    ext_glBufferData,
    ext_glBufferDataARB,
    ext_glBufferPageCommitmentARB,
    ext_glBufferPageCommitmentMemNV,
    ext_glBufferParameteriAPPLE,
    ext_glBufferRegionEnabled,
    ext_glBufferStorage,
    ext_glBufferStorageMemEXT,
    ext_glBufferSubData,
    ext_glBufferSubDataARB,
    ext_glCallCommandListNV,
    ext_glCheckFramebufferStatus,
    ext_glCheckFramebufferStatusEXT,
    ext_glCheckNamedFramebufferStatus,
    ext_glCheckNamedFramebufferStatusEXT,
    ext_glClampColor,
    ext_glClampColorARB,
    ext_glClearAccumxOES,
    ext_glClearBufferData,
    ext_glClearBufferSubData,
    ext_glClearBufferfi,
    ext_glClearBufferfv,
    ext_glClearBufferiv,
    ext_glClearBufferuiv,
    ext_glClearColorIiEXT,
    ext_glClearColorIuiEXT,
    ext_glClearColorx,
    ext_glClearColorxOES,
    ext_glClearDepthdNV,
    ext_glClearDepthf,
    ext_glClearDepthfOES,
    ext_glClearDepthx,
    ext_glClearDepthxOES,
    ext_glClearNamedBufferData,
    ext_glClearNamedBufferDataEXT,
    ext_glClearNamedBufferSubData,
    ext_glClearNamedBufferSubDataEXT,
    ext_glClearNamedFramebufferfi,
    ext_glClearNamedFramebufferfv,
    ext_glClearNamedFramebufferiv,
    ext_glClearNamedFramebufferuiv,
    ext_glClearTexImage,
    ext_glClearTexSubImage,
    ext_glClientActiveTexture,
    ext_glClientActiveTextureARB,
    ext_glClientActiveVertexStreamATI,
    ext_glClientAttribDefaultEXT,
    ext_glClientWaitSemaphoreui64NVX,
    ext_glClientWaitSync,
    ext_glClipControl,
    ext_glClipPlanef,
    ext_glClipPlanefOES,
    ext_glClipPlanex,
    ext_glClipPlanexOES,
    ext_glColor3fVertex3fSUN,
    ext_glColor3fVertex3fvSUN,
    ext_glColor3hNV,
    ext_glColor3hvNV,
    ext_glColor3xOES,
    ext_glColor3xvOES,
    ext_glColor4fNormal3fVertex3fSUN,
    ext_glColor4fNormal3fVertex3fvSUN,
    ext_glColor4hNV,
    ext_glColor4hvNV,
    ext_glColor4ubVertex2fSUN,
    ext_glColor4ubVertex2fvSUN,
    ext_glColor4ubVertex3fSUN,
    ext_glColor4ubVertex3fvSUN,
    ext_glColor4x,
    ext_glColor4xOES,
    ext_glColor4xvOES,
    ext_glColorFormatNV,
    ext_glColorFragmentOp1ATI,
    ext_glColorFragmentOp2ATI,
    ext_glColorFragmentOp3ATI,
    ext_glColorMaskIndexedEXT,
    ext_glColorMaski,
    ext_glColorP3ui,
    ext_glColorP3uiv,
    ext_glColorP4ui,
    ext_glColorP4uiv,
    ext_glColorPointerEXT,
    ext_glColorPointerListIBM,
    ext_glColorPointervINTEL,
    ext_glColorSubTable,
    ext_glColorSubTableEXT,
    ext_glColorTable,
    ext_glColorTableEXT,
    ext_glColorTableParameterfv,
    ext_glColorTableParameterfvSGI,
    ext_glColorTableParameteriv,
    ext_glColorTableParameterivSGI,
    ext_glColorTableSGI,
    ext_glCombinerInputNV,
    ext_glCombinerOutputNV,
    ext_glCombinerParameterfNV,
    ext_glCombinerParameterfvNV,
    ext_glCombinerParameteriNV,
    ext_glCombinerParameterivNV,
    ext_glCombinerStageParameterfvNV,
    ext_glCommandListSegmentsNV,
    ext_glCompileCommandListNV,
    ext_glCompileShader,
    ext_glCompileShaderARB,
    ext_glCompileShaderIncludeARB,
    ext_glCompressedMultiTexImage1DEXT,
    ext_glCompressedMultiTexImage2DEXT,
    ext_glCompressedMultiTexImage3DEXT,
    ext_glCompressedMultiTexSubImage1DEXT,
    ext_glCompressedMultiTexSubImage2DEXT,
    ext_glCompressedMultiTexSubImage3DEXT,
    ext_glCompressedTexImage1D,
    ext_glCompressedTexImage1DARB,
    ext_glCompressedTexImage2D,
    ext_glCompressedTexImage2DARB,
    ext_glCompressedTexImage3D,
    ext_glCompressedTexImage3DARB,
    ext_glCompressedTexSubImage1D,
    ext_glCompressedTexSubImage1DARB,
    ext_glCompressedTexSubImage2D,
    ext_glCompressedTexSubImage2DARB,
    ext_glCompressedTexSubImage3D,
    ext_glCompressedTexSubImage3DARB,
    ext_glCompressedTextureImage1DEXT,
    ext_glCompressedTextureImage2DEXT,
    ext_glCompressedTextureImage3DEXT,
    ext_glCompressedTextureSubImage1D,
    ext_glCompressedTextureSubImage1DEXT,
    ext_glCompressedTextureSubImage2D,
    ext_glCompressedTextureSubImage2DEXT,
    ext_glCompressedTextureSubImage3D,
    ext_glCompressedTextureSubImage3DEXT,
    ext_glConservativeRasterParameterfNV,
    ext_glConservativeRasterParameteriNV,
    ext_glConvolutionFilter1D,
    ext_glConvolutionFilter1DEXT,
    ext_glConvolutionFilter2D,
    ext_glConvolutionFilter2DEXT,
    ext_glConvolutionParameterf,
    ext_glConvolutionParameterfEXT,
    ext_glConvolutionParameterfv,
    ext_glConvolutionParameterfvEXT,
    ext_glConvolutionParameteri,
    ext_glConvolutionParameteriEXT,
    ext_glConvolutionParameteriv,
    ext_glConvolutionParameterivEXT,
    ext_glConvolutionParameterxOES,
    ext_glConvolutionParameterxvOES,
    ext_glCopyBufferSubData,
    ext_glCopyColorSubTable,
    ext_glCopyColorSubTableEXT,
    ext_glCopyColorTable,
    ext_glCopyColorTableSGI,
    ext_glCopyConvolutionFilter1D,
    ext_glCopyConvolutionFilter1DEXT,
    ext_glCopyConvolutionFilter2D,
    ext_glCopyConvolutionFilter2DEXT,
    ext_glCopyImageSubData,
    ext_glCopyImageSubDataNV,
    ext_glCopyMultiTexImage1DEXT,
    ext_glCopyMultiTexImage2DEXT,
    ext_glCopyMultiTexSubImage1DEXT,
    ext_glCopyMultiTexSubImage2DEXT,
    ext_glCopyMultiTexSubImage3DEXT,
    ext_glCopyNamedBufferSubData,
    ext_glCopyPathNV,
    ext_glCopyTexImage1DEXT,
    ext_glCopyTexImage2DEXT,
    ext_glCopyTexSubImage1DEXT,
    ext_glCopyTexSubImage2DEXT,
    ext_glCopyTexSubImage3D,
    ext_glCopyTexSubImage3DEXT,
    ext_glCopyTextureImage1DEXT,
    ext_glCopyTextureImage2DEXT,
    ext_glCopyTextureSubImage1D,
    ext_glCopyTextureSubImage1DEXT,
    ext_glCopyTextureSubImage2D,
    ext_glCopyTextureSubImage2DEXT,
    ext_glCopyTextureSubImage3D,
    ext_glCopyTextureSubImage3DEXT,
    ext_glCoverFillPathInstancedNV,
    ext_glCoverFillPathNV,
    ext_glCoverStrokePathInstancedNV,
    ext_glCoverStrokePathNV,
    ext_glCoverageModulationNV,
    ext_glCoverageModulationTableNV,
    ext_glCreateBuffers,
    ext_glCreateCommandListsNV,
    ext_glCreateFramebuffers,
    ext_glCreateMemoryObjectsEXT,
    ext_glCreatePerfQueryINTEL,
    ext_glCreateProgram,
    ext_glCreateProgramObjectARB,
    ext_glCreateProgramPipelines,
    ext_glCreateProgressFenceNVX,
    ext_glCreateQueries,
    ext_glCreateRenderbuffers,
    ext_glCreateSamplers,
    ext_glCreateSemaphoresNV,
    ext_glCreateShader,
    ext_glCreateShaderObjectARB,
    ext_glCreateShaderProgramEXT,
    ext_glCreateShaderProgramv,
    ext_glCreateStatesNV,
    ext_glCreateSyncFromCLeventARB,
    ext_glCreateTextures,
    ext_glCreateTransformFeedbacks,
    ext_glCreateVertexArrays,
    ext_glCullParameterdvEXT,
    ext_glCullParameterfvEXT,
    ext_glCurrentPaletteMatrixARB,
    ext_glDebugMessageCallback,
    ext_glDebugMessageCallbackAMD,
    ext_glDebugMessageCallbackARB,
    ext_glDebugMessageControl,
    ext_glDebugMessageControlARB,
    ext_glDebugMessageEnableAMD,
    ext_glDebugMessageInsert,
    ext_glDebugMessageInsertAMD,
    ext_glDebugMessageInsertARB,
    ext_glDeformSGIX,
    ext_glDeformationMap3dSGIX,
    ext_glDeformationMap3fSGIX,
    ext_glDeleteAsyncMarkersSGIX,
    ext_glDeleteBufferRegion,
    ext_glDeleteBuffers,
    ext_glDeleteBuffersARB,
    ext_glDeleteCommandListsNV,
    ext_glDeleteFencesAPPLE,
    ext_glDeleteFencesNV,
    ext_glDeleteFragmentShaderATI,
    ext_glDeleteFramebuffers,
    ext_glDeleteFramebuffersEXT,
    ext_glDeleteMemoryObjectsEXT,
    ext_glDeleteNamedStringARB,
    ext_glDeleteNamesAMD,
    ext_glDeleteObjectARB,
    ext_glDeleteObjectBufferATI,
    ext_glDeleteOcclusionQueriesNV,
    ext_glDeletePathsNV,
    ext_glDeletePerfMonitorsAMD,
    ext_glDeletePerfQueryINTEL,
    ext_glDeleteProgram,
    ext_glDeleteProgramPipelines,
    ext_glDeleteProgramsARB,
    ext_glDeleteProgramsNV,
    ext_glDeleteQueries,
    ext_glDeleteQueriesARB,
    ext_glDeleteQueryResourceTagNV,
    ext_glDeleteRenderbuffers,
    ext_glDeleteRenderbuffersEXT,
    ext_glDeleteSamplers,
    ext_glDeleteSemaphoresEXT,
    ext_glDeleteShader,
    ext_glDeleteStatesNV,
    ext_glDeleteSync,
    ext_glDeleteTexturesEXT,
    ext_glDeleteTransformFeedbacks,
    ext_glDeleteTransformFeedbacksNV,
    ext_glDeleteVertexArrays,
    ext_glDeleteVertexArraysAPPLE,
    ext_glDeleteVertexShaderEXT,
    ext_glDepthBoundsEXT,
    ext_glDepthBoundsdNV,
    ext_glDepthRangeArraydvNV,
    ext_glDepthRangeArrayv,
    ext_glDepthRangeIndexed,
    ext_glDepthRangeIndexeddNV,
    ext_glDepthRangedNV,
    ext_glDepthRangef,
    ext_glDepthRangefOES,
    ext_glDepthRangex,
    ext_glDepthRangexOES,
    ext_glDetachObjectARB,
    ext_glDetachShader,
    ext_glDetailTexFuncSGIS,
    ext_glDisableClientStateIndexedEXT,
    ext_glDisableClientStateiEXT,
    ext_glDisableIndexedEXT,
    ext_glDisableVariantClientStateEXT,
    ext_glDisableVertexArrayAttrib,
    ext_glDisableVertexArrayAttribEXT,
    ext_glDisableVertexArrayEXT,
    ext_glDisableVertexAttribAPPLE,
    ext_glDisableVertexAttribArray,
    ext_glDisableVertexAttribArrayARB,
    ext_glDisablei,
    ext_glDispatchCompute,
    ext_glDispatchComputeGroupSizeARB,
    ext_glDispatchComputeIndirect,
    ext_glDrawArraysEXT,
    ext_glDrawArraysIndirect,
    ext_glDrawArraysInstanced,
    ext_glDrawArraysInstancedARB,
    ext_glDrawArraysInstancedBaseInstance,
    ext_glDrawArraysInstancedEXT,
    ext_glDrawBufferRegion,
    ext_glDrawBuffers,
    ext_glDrawBuffersARB,
    ext_glDrawBuffersATI,
    ext_glDrawCommandsAddressNV,
    ext_glDrawCommandsNV,
    ext_glDrawCommandsStatesAddressNV,
    ext_glDrawCommandsStatesNV,
    ext_glDrawElementArrayAPPLE,
    ext_glDrawElementArrayATI,
    ext_glDrawElementsBaseVertex,
    ext_glDrawElementsIndirect,
    ext_glDrawElementsInstanced,
    ext_glDrawElementsInstancedARB,
    ext_glDrawElementsInstancedBaseInstance,
    ext_glDrawElementsInstancedBaseVertex,
    ext_glDrawElementsInstancedBaseVertexBaseInstance,
    ext_glDrawElementsInstancedEXT,
    ext_glDrawMeshArraysSUN,
    ext_glDrawMeshTasksEXT,
    ext_glDrawMeshTasksIndirectEXT,
    ext_glDrawMeshTasksIndirectNV,
    ext_glDrawMeshTasksNV,
    ext_glDrawRangeElementArrayAPPLE,
    ext_glDrawRangeElementArrayATI,
    ext_glDrawRangeElements,
    ext_glDrawRangeElementsBaseVertex,
    ext_glDrawRangeElementsEXT,
    ext_glDrawTextureNV,
    ext_glDrawTransformFeedback,
    ext_glDrawTransformFeedbackInstanced,
    ext_glDrawTransformFeedbackNV,
    ext_glDrawTransformFeedbackStream,
    ext_glDrawTransformFeedbackStreamInstanced,
    ext_glDrawVkImageNV,
    ext_glEGLImageTargetTexStorageEXT,
    ext_glEGLImageTargetTextureStorageEXT,
    ext_glEdgeFlagFormatNV,
    ext_glEdgeFlagPointerEXT,
    ext_glEdgeFlagPointerListIBM,
    ext_glElementPointerAPPLE,
    ext_glElementPointerATI,
    ext_glEnableClientStateIndexedEXT,
    ext_glEnableClientStateiEXT,
    ext_glEnableIndexedEXT,
    ext_glEnableVariantClientStateEXT,
    ext_glEnableVertexArrayAttrib,
    ext_glEnableVertexArrayAttribEXT,
    ext_glEnableVertexArrayEXT,
    ext_glEnableVertexAttribAPPLE,
    ext_glEnableVertexAttribArray,
    ext_glEnableVertexAttribArrayARB,
    ext_glEnablei,
    ext_glEndConditionalRender,
    ext_glEndConditionalRenderNV,
    ext_glEndConditionalRenderNVX,
    ext_glEndFragmentShaderATI,
    ext_glEndOcclusionQueryNV,
    ext_glEndPerfMonitorAMD,
    ext_glEndPerfQueryINTEL,
    ext_glEndQuery,
    ext_glEndQueryARB,
    ext_glEndQueryIndexed,
    ext_glEndTransformFeedback,
    ext_glEndTransformFeedbackEXT,
    ext_glEndTransformFeedbackNV,
    ext_glEndVertexShaderEXT,
    ext_glEndVideoCaptureNV,
    ext_glEvalCoord1xOES,
    ext_glEvalCoord1xvOES,
    ext_glEvalCoord2xOES,
    ext_glEvalCoord2xvOES,
    ext_glEvalMapsNV,
    ext_glEvaluateDepthValuesARB,
    ext_glExecuteProgramNV,
    ext_glExtractComponentEXT,
    ext_glFeedbackBufferxOES,
    ext_glFenceSync,
    ext_glFinalCombinerInputNV,
    ext_glFinishAsyncSGIX,
    ext_glFinishFenceAPPLE,
    ext_glFinishFenceNV,
    ext_glFinishObjectAPPLE,
    ext_glFinishTextureSUNX,
    ext_glFlushMappedBufferRange,
    ext_glFlushMappedBufferRangeAPPLE,
    ext_glFlushMappedNamedBufferRange,
    ext_glFlushMappedNamedBufferRangeEXT,
    ext_glFlushPixelDataRangeNV,
    ext_glFlushRasterSGIX,
    ext_glFlushStaticDataIBM,
    ext_glFlushVertexArrayRangeAPPLE,
    ext_glFlushVertexArrayRangeNV,
    ext_glFogCoordFormatNV,
    ext_glFogCoordPointer,
    ext_glFogCoordPointerEXT,
    ext_glFogCoordPointerListIBM,
    ext_glFogCoordd,
    ext_glFogCoorddEXT,
    ext_glFogCoorddv,
    ext_glFogCoorddvEXT,
    ext_glFogCoordf,
    ext_glFogCoordfEXT,
    ext_glFogCoordfv,
    ext_glFogCoordfvEXT,
    ext_glFogCoordhNV,
    ext_glFogCoordhvNV,
    ext_glFogFuncSGIS,
    ext_glFogx,
    ext_glFogxOES,
    ext_glFogxv,
    ext_glFogxvOES,
    ext_glFragmentColorMaterialSGIX,
    ext_glFragmentCoverageColorNV,
    ext_glFragmentLightModelfSGIX,
    ext_glFragmentLightModelfvSGIX,
    ext_glFragmentLightModeliSGIX,
    ext_glFragmentLightModelivSGIX,
    ext_glFragmentLightfSGIX,
    ext_glFragmentLightfvSGIX,
    ext_glFragmentLightiSGIX,
    ext_glFragmentLightivSGIX,
    ext_glFragmentMaterialfSGIX,
    ext_glFragmentMaterialfvSGIX,
    ext_glFragmentMaterialiSGIX,
    ext_glFragmentMaterialivSGIX,
    ext_glFrameTerminatorGREMEDY,
    ext_glFrameZoomSGIX,
    ext_glFramebufferDrawBufferEXT,
    ext_glFramebufferDrawBuffersEXT,
    ext_glFramebufferFetchBarrierEXT,
    ext_glFramebufferParameteri,
    ext_glFramebufferParameteriMESA,
    ext_glFramebufferReadBufferEXT,
    ext_glFramebufferRenderbuffer,
    ext_glFramebufferRenderbufferEXT,
    ext_glFramebufferSampleLocationsfvARB,
    ext_glFramebufferSampleLocationsfvNV,
    ext_glFramebufferSamplePositionsfvAMD,
    ext_glFramebufferShadingRateEXT,
    ext_glFramebufferTexture,
    ext_glFramebufferTexture1D,
    ext_glFramebufferTexture1DEXT,
    ext_glFramebufferTexture2D,
    ext_glFramebufferTexture2DEXT,
    ext_glFramebufferTexture3D,
    ext_glFramebufferTexture3DEXT,
    ext_glFramebufferTextureARB,
    ext_glFramebufferTextureEXT,
    ext_glFramebufferTextureFaceARB,
    ext_glFramebufferTextureFaceEXT,
    ext_glFramebufferTextureLayer,
    ext_glFramebufferTextureLayerARB,
    ext_glFramebufferTextureLayerEXT,
    ext_glFramebufferTextureMultiviewOVR,
    ext_glFreeObjectBufferATI,
    ext_glFrustumf,
    ext_glFrustumfOES,
    ext_glFrustumx,
    ext_glFrustumxOES,
    ext_glGenAsyncMarkersSGIX,
    ext_glGenBuffers,
    ext_glGenBuffersARB,
    ext_glGenFencesAPPLE,
    ext_glGenFencesNV,
    ext_glGenFragmentShadersATI,
    ext_glGenFramebuffers,
    ext_glGenFramebuffersEXT,
    ext_glGenNamesAMD,
    ext_glGenOcclusionQueriesNV,
    ext_glGenPathsNV,
    ext_glGenPerfMonitorsAMD,
    ext_glGenProgramPipelines,
    ext_glGenProgramsARB,
    ext_glGenProgramsNV,
    ext_glGenQueries,
    ext_glGenQueriesARB,
    ext_glGenQueryResourceTagNV,
    ext_glGenRenderbuffers,
    ext_glGenRenderbuffersEXT,
    ext_glGenSamplers,
    ext_glGenSemaphoresEXT,
    ext_glGenSymbolsEXT,
    ext_glGenTexturesEXT,
    ext_glGenTransformFeedbacks,
    ext_glGenTransformFeedbacksNV,
    ext_glGenVertexArrays,
    ext_glGenVertexArraysAPPLE,
    ext_glGenVertexShadersEXT,
    ext_glGenerateMipmap,
    ext_glGenerateMipmapEXT,
    ext_glGenerateMultiTexMipmapEXT,
    ext_glGenerateTextureMipmap,
    ext_glGenerateTextureMipmapEXT,
    ext_glGetActiveAtomicCounterBufferiv,
    ext_glGetActiveAttrib,
    ext_glGetActiveAttribARB,
    ext_glGetActiveSubroutineName,
    ext_glGetActiveSubroutineUniformName,
    ext_glGetActiveSubroutineUniformiv,
    ext_glGetActiveUniform,
    ext_glGetActiveUniformARB,
    ext_glGetActiveUniformBlockName,
    ext_glGetActiveUniformBlockiv,
    ext_glGetActiveUniformName,
    ext_glGetActiveUniformsiv,
    ext_glGetActiveVaryingNV,
    ext_glGetArrayObjectfvATI,
    ext_glGetArrayObjectivATI,
    ext_glGetAttachedObjectsARB,
    ext_glGetAttachedShaders,
    ext_glGetAttribLocation,
    ext_glGetAttribLocationARB,
    ext_glGetBooleanIndexedvEXT,
    ext_glGetBooleani_v,
    ext_glGetBufferParameteri64v,
    ext_glGetBufferParameteriv,
    ext_glGetBufferParameterivARB,
    ext_glGetBufferParameterui64vNV,
    ext_glGetBufferPointerv,
    ext_glGetBufferPointervARB,
    ext_glGetBufferSubData,
    ext_glGetBufferSubDataARB,
    ext_glGetClipPlanef,
    ext_glGetClipPlanefOES,
    ext_glGetClipPlanex,
    ext_glGetClipPlanexOES,
    ext_glGetColorTable,
    ext_glGetColorTableEXT,
    ext_glGetColorTableParameterfv,
    ext_glGetColorTableParameterfvEXT,
    ext_glGetColorTableParameterfvSGI,
    ext_glGetColorTableParameteriv,
    ext_glGetColorTableParameterivEXT,
    ext_glGetColorTableParameterivSGI,
    ext_glGetColorTableSGI,
    ext_glGetCombinerInputParameterfvNV,
    ext_glGetCombinerInputParameterivNV,
    ext_glGetCombinerOutputParameterfvNV,
    ext_glGetCombinerOutputParameterivNV,
    ext_glGetCombinerStageParameterfvNV,
    ext_glGetCommandHeaderNV,
    ext_glGetCompressedMultiTexImageEXT,
    ext_glGetCompressedTexImage,
    ext_glGetCompressedTexImageARB,
    ext_glGetCompressedTextureImage,
    ext_glGetCompressedTextureImageEXT,
    ext_glGetCompressedTextureSubImage,
    ext_glGetConvolutionFilter,
    ext_glGetConvolutionFilterEXT,
    ext_glGetConvolutionParameterfv,
    ext_glGetConvolutionParameterfvEXT,
    ext_glGetConvolutionParameteriv,
    ext_glGetConvolutionParameterivEXT,
    ext_glGetConvolutionParameterxvOES,
    ext_glGetCoverageModulationTableNV,
    ext_glGetDebugMessageLog,
    ext_glGetDebugMessageLogAMD,
    ext_glGetDebugMessageLogARB,
    ext_glGetDetailTexFuncSGIS,
    ext_glGetDoubleIndexedvEXT,
    ext_glGetDoublei_v,
    ext_glGetDoublei_vEXT,
    ext_glGetFenceivNV,
    ext_glGetFinalCombinerInputParameterfvNV,
    ext_glGetFinalCombinerInputParameterivNV,
    ext_glGetFirstPerfQueryIdINTEL,
    ext_glGetFixedv,
    ext_glGetFixedvOES,
    ext_glGetFloatIndexedvEXT,
    ext_glGetFloati_v,
    ext_glGetFloati_vEXT,
    ext_glGetFogFuncSGIS,
    ext_glGetFragDataIndex,
    ext_glGetFragDataLocation,
    ext_glGetFragDataLocationEXT,
    ext_glGetFragmentLightfvSGIX,
    ext_glGetFragmentLightivSGIX,
    ext_glGetFragmentMaterialfvSGIX,
    ext_glGetFragmentMaterialivSGIX,
    ext_glGetFragmentShadingRatesEXT,
    ext_glGetFramebufferAttachmentParameteriv,
    ext_glGetFramebufferAttachmentParameterivEXT,
    ext_glGetFramebufferParameterfvAMD,
    ext_glGetFramebufferParameteriv,
    ext_glGetFramebufferParameterivEXT,
    ext_glGetFramebufferParameterivMESA,
    ext_glGetGraphicsResetStatus,
    ext_glGetGraphicsResetStatusARB,
    ext_glGetHandleARB,
    ext_glGetHistogram,
    ext_glGetHistogramEXT,
    ext_glGetHistogramParameterfv,
    ext_glGetHistogramParameterfvEXT,
    ext_glGetHistogramParameteriv,
    ext_glGetHistogramParameterivEXT,
    ext_glGetHistogramParameterxvOES,
    ext_glGetImageHandleARB,
    ext_glGetImageHandleNV,
    ext_glGetImageTransformParameterfvHP,
    ext_glGetImageTransformParameterivHP,
    ext_glGetInfoLogARB,
    ext_glGetInstrumentsSGIX,
    ext_glGetInteger64i_v,
    ext_glGetInteger64v,
    ext_glGetIntegerIndexedvEXT,
    ext_glGetIntegeri_v,
    ext_glGetIntegerui64i_vNV,
    ext_glGetIntegerui64vNV,
    ext_glGetInternalformatSampleivNV,
    ext_glGetInternalformati64v,
    ext_glGetInternalformativ,
    ext_glGetInvariantBooleanvEXT,
    ext_glGetInvariantFloatvEXT,
    ext_glGetInvariantIntegervEXT,
    ext_glGetLightxOES,
    ext_glGetLightxv,
    ext_glGetListParameterfvSGIX,
    ext_glGetListParameterivSGIX,
    ext_glGetLocalConstantBooleanvEXT,
    ext_glGetLocalConstantFloatvEXT,
    ext_glGetLocalConstantIntegervEXT,
    ext_glGetMapAttribParameterfvNV,
    ext_glGetMapAttribParameterivNV,
    ext_glGetMapControlPointsNV,
    ext_glGetMapParameterfvNV,
    ext_glGetMapParameterivNV,
    ext_glGetMapxvOES,
    ext_glGetMaterialxOES,
    ext_glGetMaterialxv,
    ext_glGetMemoryObjectDetachedResourcesuivNV,
    ext_glGetMemoryObjectParameterivEXT,
    ext_glGetMinmax,
    ext_glGetMinmaxEXT,
    ext_glGetMinmaxParameterfv,
    ext_glGetMinmaxParameterfvEXT,
    ext_glGetMinmaxParameteriv,
    ext_glGetMinmaxParameterivEXT,
    ext_glGetMultiTexEnvfvEXT,
    ext_glGetMultiTexEnvivEXT,
    ext_glGetMultiTexGendvEXT,
    ext_glGetMultiTexGenfvEXT,
    ext_glGetMultiTexGenivEXT,
    ext_glGetMultiTexImageEXT,
    ext_glGetMultiTexLevelParameterfvEXT,
    ext_glGetMultiTexLevelParameterivEXT,
    ext_glGetMultiTexParameterIivEXT,
    ext_glGetMultiTexParameterIuivEXT,
    ext_glGetMultiTexParameterfvEXT,
    ext_glGetMultiTexParameterivEXT,
    ext_glGetMultisamplefv,
    ext_glGetMultisamplefvNV,
    ext_glGetNamedBufferParameteri64v,
    ext_glGetNamedBufferParameteriv,
    ext_glGetNamedBufferParameterivEXT,
    ext_glGetNamedBufferParameterui64vNV,
    ext_glGetNamedBufferPointerv,
    ext_glGetNamedBufferPointervEXT,
    ext_glGetNamedBufferSubData,
    ext_glGetNamedBufferSubDataEXT,
    ext_glGetNamedFramebufferAttachmentParameteriv,
    ext_glGetNamedFramebufferAttachmentParameterivEXT,
    ext_glGetNamedFramebufferParameterfvAMD,
    ext_glGetNamedFramebufferParameteriv,
    ext_glGetNamedFramebufferParameterivEXT,
    ext_glGetNamedProgramLocalParameterIivEXT,
    ext_glGetNamedProgramLocalParameterIuivEXT,
    ext_glGetNamedProgramLocalParameterdvEXT,
    ext_glGetNamedProgramLocalParameterfvEXT,
    ext_glGetNamedProgramStringEXT,
    ext_glGetNamedProgramivEXT,
    ext_glGetNamedRenderbufferParameteriv,
    ext_glGetNamedRenderbufferParameterivEXT,
    ext_glGetNamedStringARB,
    ext_glGetNamedStringivARB,
    ext_glGetNextPerfQueryIdINTEL,
    ext_glGetObjectBufferfvATI,
    ext_glGetObjectBufferivATI,
    ext_glGetObjectLabel,
    ext_glGetObjectLabelEXT,
    ext_glGetObjectParameterfvARB,
    ext_glGetObjectParameterivAPPLE,
    ext_glGetObjectParameterivARB,
    ext_glGetObjectPtrLabel,
    ext_glGetOcclusionQueryivNV,
    ext_glGetOcclusionQueryuivNV,
    ext_glGetPathColorGenfvNV,
    ext_glGetPathColorGenivNV,
    ext_glGetPathCommandsNV,
    ext_glGetPathCoordsNV,
    ext_glGetPathDashArrayNV,
    ext_glGetPathLengthNV,
    ext_glGetPathMetricRangeNV,
    ext_glGetPathMetricsNV,
    ext_glGetPathParameterfvNV,
    ext_glGetPathParameterivNV,
    ext_glGetPathSpacingNV,
    ext_glGetPathTexGenfvNV,
    ext_glGetPathTexGenivNV,
    ext_glGetPerfCounterInfoINTEL,
    ext_glGetPerfMonitorCounterDataAMD,
    ext_glGetPerfMonitorCounterInfoAMD,
    ext_glGetPerfMonitorCounterStringAMD,
    ext_glGetPerfMonitorCountersAMD,
    ext_glGetPerfMonitorGroupStringAMD,
    ext_glGetPerfMonitorGroupsAMD,
    ext_glGetPerfQueryDataINTEL,
    ext_glGetPerfQueryIdByNameINTEL,
    ext_glGetPerfQueryInfoINTEL,
    ext_glGetPixelMapxv,
    ext_glGetPixelTexGenParameterfvSGIS,
    ext_glGetPixelTexGenParameterivSGIS,
    ext_glGetPixelTransformParameterfvEXT,
    ext_glGetPixelTransformParameterivEXT,
    ext_glGetPointerIndexedvEXT,
    ext_glGetPointeri_vEXT,
    ext_glGetPointervEXT,
    ext_glGetProgramBinary,
    ext_glGetProgramEnvParameterIivNV,
    ext_glGetProgramEnvParameterIuivNV,
    ext_glGetProgramEnvParameterdvARB,
    ext_glGetProgramEnvParameterfvARB,
    ext_glGetProgramInfoLog,
    ext_glGetProgramInterfaceiv,
    ext_glGetProgramLocalParameterIivNV,
    ext_glGetProgramLocalParameterIuivNV,
    ext_glGetProgramLocalParameterdvARB,
    ext_glGetProgramLocalParameterfvARB,
    ext_glGetProgramNamedParameterdvNV,
    ext_glGetProgramNamedParameterfvNV,
    ext_glGetProgramParameterdvNV,
    ext_glGetProgramParameterfvNV,
    ext_glGetProgramPipelineInfoLog,
    ext_glGetProgramPipelineiv,
    ext_glGetProgramResourceIndex,
    ext_glGetProgramResourceLocation,
    ext_glGetProgramResourceLocationIndex,
    ext_glGetProgramResourceName,
    ext_glGetProgramResourcefvNV,
    ext_glGetProgramResourceiv,
    ext_glGetProgramStageiv,
    ext_glGetProgramStringARB,
    ext_glGetProgramStringNV,
    ext_glGetProgramSubroutineParameteruivNV,
    ext_glGetProgramiv,
    ext_glGetProgramivARB,
    ext_glGetProgramivNV,
    ext_glGetQueryBufferObjecti64v,
    ext_glGetQueryBufferObjectiv,
    ext_glGetQueryBufferObjectui64v,
    ext_glGetQueryBufferObjectuiv,
    ext_glGetQueryIndexediv,
    ext_glGetQueryObjecti64v,
    ext_glGetQueryObjecti64vEXT,
    ext_glGetQueryObjectiv,
    ext_glGetQueryObjectivARB,
    ext_glGetQueryObjectui64v,
    ext_glGetQueryObjectui64vEXT,
    ext_glGetQueryObjectuiv,
    ext_glGetQueryObjectuivARB,
    ext_glGetQueryiv,
    ext_glGetQueryivARB,
    ext_glGetRenderbufferParameteriv,
    ext_glGetRenderbufferParameterivEXT,
    ext_glGetSamplerParameterIiv,
    ext_glGetSamplerParameterIuiv,
    ext_glGetSamplerParameterfv,
    ext_glGetSamplerParameteriv,
    ext_glGetSemaphoreParameterivNV,
    ext_glGetSemaphoreParameterui64vEXT,
    ext_glGetSeparableFilter,
    ext_glGetSeparableFilterEXT,
    ext_glGetShaderInfoLog,
    ext_glGetShaderPrecisionFormat,
    ext_glGetShaderSource,
    ext_glGetShaderSourceARB,
    ext_glGetShaderiv,
    ext_glGetShadingRateImagePaletteNV,
    ext_glGetShadingRateSampleLocationivNV,
    ext_glGetSharpenTexFuncSGIS,
    ext_glGetStageIndexNV,
    ext_glGetStringi,
    ext_glGetSubroutineIndex,
    ext_glGetSubroutineUniformLocation,
    ext_glGetSynciv,
    ext_glGetTexBumpParameterfvATI,
    ext_glGetTexBumpParameterivATI,
    ext_glGetTexEnvxv,
    ext_glGetTexEnvxvOES,
    ext_glGetTexFilterFuncSGIS,
    ext_glGetTexGenxvOES,
    ext_glGetTexLevelParameterxvOES,
    ext_glGetTexParameterIiv,
    ext_glGetTexParameterIivEXT,
    ext_glGetTexParameterIuiv,
    ext_glGetTexParameterIuivEXT,
    ext_glGetTexParameterPointervAPPLE,
    ext_glGetTexParameterxv,
    ext_glGetTexParameterxvOES,
    ext_glGetTextureHandleARB,
    ext_glGetTextureHandleNV,
    ext_glGetTextureImage,
    ext_glGetTextureImageEXT,
    ext_glGetTextureLevelParameterfv,
    ext_glGetTextureLevelParameterfvEXT,
    ext_glGetTextureLevelParameteriv,
    ext_glGetTextureLevelParameterivEXT,
    ext_glGetTextureParameterIiv,
    ext_glGetTextureParameterIivEXT,
    ext_glGetTextureParameterIuiv,
    ext_glGetTextureParameterIuivEXT,
    ext_glGetTextureParameterfv,
    ext_glGetTextureParameterfvEXT,
    ext_glGetTextureParameteriv,
    ext_glGetTextureParameterivEXT,
    ext_glGetTextureSamplerHandleARB,
    ext_glGetTextureSamplerHandleNV,
    ext_glGetTextureSubImage,
    ext_glGetTrackMatrixivNV,
    ext_glGetTransformFeedbackVarying,
    ext_glGetTransformFeedbackVaryingEXT,
    ext_glGetTransformFeedbackVaryingNV,
    ext_glGetTransformFeedbacki64_v,
    ext_glGetTransformFeedbacki_v,
    ext_glGetTransformFeedbackiv,
    ext_glGetUniformBlockIndex,
    ext_glGetUniformBufferSizeEXT,
    ext_glGetUniformIndices,
    ext_glGetUniformLocation,
    ext_glGetUniformLocationARB,
    ext_glGetUniformOffsetEXT,
    ext_glGetUniformSubroutineuiv,
    ext_glGetUniformdv,
    ext_glGetUniformfv,
    ext_glGetUniformfvARB,
    ext_glGetUniformi64vARB,
    ext_glGetUniformi64vNV,
    ext_glGetUniformiv,
    ext_glGetUniformivARB,
    ext_glGetUniformui64vARB,
    ext_glGetUniformui64vNV,
    ext_glGetUniformuiv,
    ext_glGetUniformuivEXT,
    ext_glGetUnsignedBytei_vEXT,
    ext_glGetUnsignedBytevEXT,
    ext_glGetVariantArrayObjectfvATI,
    ext_glGetVariantArrayObjectivATI,
    ext_glGetVariantBooleanvEXT,
    ext_glGetVariantFloatvEXT,
    ext_glGetVariantIntegervEXT,
    ext_glGetVariantPointervEXT,
    ext_glGetVaryingLocationNV,
    ext_glGetVertexArrayIndexed64iv,
    ext_glGetVertexArrayIndexediv,
    ext_glGetVertexArrayIntegeri_vEXT,
    ext_glGetVertexArrayIntegervEXT,
    ext_glGetVertexArrayPointeri_vEXT,
    ext_glGetVertexArrayPointervEXT,
    ext_glGetVertexArrayiv,
    ext_glGetVertexAttribArrayObjectfvATI,
    ext_glGetVertexAttribArrayObjectivATI,
    ext_glGetVertexAttribIiv,
    ext_glGetVertexAttribIivEXT,
    ext_glGetVertexAttribIuiv,
    ext_glGetVertexAttribIuivEXT,
    ext_glGetVertexAttribLdv,
    ext_glGetVertexAttribLdvEXT,
    ext_glGetVertexAttribLi64vNV,
    ext_glGetVertexAttribLui64vARB,
    ext_glGetVertexAttribLui64vNV,
    ext_glGetVertexAttribPointerv,
    ext_glGetVertexAttribPointervARB,
    ext_glGetVertexAttribPointervNV,
    ext_glGetVertexAttribdv,
    ext_glGetVertexAttribdvARB,
    ext_glGetVertexAttribdvNV,
    ext_glGetVertexAttribfv,
    ext_glGetVertexAttribfvARB,
    ext_glGetVertexAttribfvNV,
    ext_glGetVertexAttribiv,
    ext_glGetVertexAttribivARB,
    ext_glGetVertexAttribivNV,
    ext_glGetVideoCaptureStreamdvNV,
    ext_glGetVideoCaptureStreamfvNV,
    ext_glGetVideoCaptureStreamivNV,
    ext_glGetVideoCaptureivNV,
    ext_glGetVideoi64vNV,
    ext_glGetVideoivNV,
    ext_glGetVideoui64vNV,
    ext_glGetVideouivNV,
    ext_glGetVkProcAddrNV,
    ext_glGetnColorTable,
    ext_glGetnColorTableARB,
    ext_glGetnCompressedTexImage,
    ext_glGetnCompressedTexImageARB,
    ext_glGetnConvolutionFilter,
    ext_glGetnConvolutionFilterARB,
    ext_glGetnHistogram,
    ext_glGetnHistogramARB,
    ext_glGetnMapdv,
    ext_glGetnMapdvARB,
    ext_glGetnMapfv,
    ext_glGetnMapfvARB,
    ext_glGetnMapiv,
    ext_glGetnMapivARB,
    ext_glGetnMinmax,
    ext_glGetnMinmaxARB,
    ext_glGetnPixelMapfv,
    ext_glGetnPixelMapfvARB,
    ext_glGetnPixelMapuiv,
    ext_glGetnPixelMapuivARB,
    ext_glGetnPixelMapusv,
    ext_glGetnPixelMapusvARB,
    ext_glGetnPolygonStipple,
    ext_glGetnPolygonStippleARB,
    ext_glGetnSeparableFilter,
    ext_glGetnSeparableFilterARB,
    ext_glGetnTexImage,
    ext_glGetnTexImageARB,
    ext_glGetnUniformdv,
    ext_glGetnUniformdvARB,
    ext_glGetnUniformfv,
    ext_glGetnUniformfvARB,
    ext_glGetnUniformi64vARB,
    ext_glGetnUniformiv,
    ext_glGetnUniformivARB,
    ext_glGetnUniformui64vARB,
    ext_glGetnUniformuiv,
    ext_glGetnUniformuivARB,
    ext_glGlobalAlphaFactorbSUN,
    ext_glGlobalAlphaFactordSUN,
    ext_glGlobalAlphaFactorfSUN,
    ext_glGlobalAlphaFactoriSUN,
    ext_glGlobalAlphaFactorsSUN,
    ext_glGlobalAlphaFactorubSUN,
    ext_glGlobalAlphaFactoruiSUN,
    ext_glGlobalAlphaFactorusSUN,
    ext_glHintPGI,
    ext_glHistogram,
    ext_glHistogramEXT,
    ext_glIglooInterfaceSGIX,
    ext_glImageTransformParameterfHP,
    ext_glImageTransformParameterfvHP,
    ext_glImageTransformParameteriHP,
    ext_glImageTransformParameterivHP,
    ext_glImportMemoryWin32HandleEXT,
    ext_glImportMemoryWin32NameEXT,
    ext_glImportSemaphoreWin32HandleEXT,
    ext_glImportSemaphoreWin32NameEXT,
    ext_glImportSyncEXT,
    ext_glIndexFormatNV,
    ext_glIndexFuncEXT,
    ext_glIndexMaterialEXT,
    ext_glIndexPointerEXT,
    ext_glIndexPointerListIBM,
    ext_glIndexxOES,
    ext_glIndexxvOES,
    ext_glInsertComponentEXT,
    ext_glInsertEventMarkerEXT,
    ext_glInstrumentsBufferSGIX,
    ext_glInterpolatePathsNV,
    ext_glInvalidateBufferData,
    ext_glInvalidateBufferSubData,
    ext_glInvalidateFramebuffer,
    ext_glInvalidateNamedFramebufferData,
    ext_glInvalidateNamedFramebufferSubData,
    ext_glInvalidateSubFramebuffer,
    ext_glInvalidateTexImage,
    ext_glInvalidateTexSubImage,
    ext_glIsAsyncMarkerSGIX,
    ext_glIsBuffer,
    ext_glIsBufferARB,
    ext_glIsBufferResidentNV,
    ext_glIsCommandListNV,
    ext_glIsEnabledIndexedEXT,
    ext_glIsEnabledi,
    ext_glIsFenceAPPLE,
    ext_glIsFenceNV,
    ext_glIsFramebuffer,
    ext_glIsFramebufferEXT,
    ext_glIsImageHandleResidentARB,
    ext_glIsImageHandleResidentNV,
    ext_glIsMemoryObjectEXT,
    ext_glIsNameAMD,
    ext_glIsNamedBufferResidentNV,
    ext_glIsNamedStringARB,
    ext_glIsObjectBufferATI,
    ext_glIsOcclusionQueryNV,
    ext_glIsPathNV,
    ext_glIsPointInFillPathNV,
    ext_glIsPointInStrokePathNV,
    ext_glIsProgram,
    ext_glIsProgramARB,
    ext_glIsProgramNV,
    ext_glIsProgramPipeline,
    ext_glIsQuery,
    ext_glIsQueryARB,
    ext_glIsRenderbuffer,
    ext_glIsRenderbufferEXT,
    ext_glIsSampler,
    ext_glIsSemaphoreEXT,
    ext_glIsShader,
    ext_glIsStateNV,
    ext_glIsSync,
    ext_glIsTextureEXT,
    ext_glIsTextureHandleResidentARB,
    ext_glIsTextureHandleResidentNV,
    ext_glIsTransformFeedback,
    ext_glIsTransformFeedbackNV,
    ext_glIsVariantEnabledEXT,
    ext_glIsVertexArray,
    ext_glIsVertexArrayAPPLE,
    ext_glIsVertexAttribEnabledAPPLE,
    ext_glLGPUCopyImageSubDataNVX,
    ext_glLGPUInterlockNVX,
    ext_glLGPUNamedBufferSubDataNVX,
    ext_glLabelObjectEXT,
    ext_glLightEnviSGIX,
    ext_glLightModelx,
    ext_glLightModelxOES,
    ext_glLightModelxv,
    ext_glLightModelxvOES,
    ext_glLightx,
    ext_glLightxOES,
    ext_glLightxv,
    ext_glLightxvOES,
    ext_glLineWidthx,
    ext_glLineWidthxOES,
    ext_glLinkProgram,
    ext_glLinkProgramARB,
    ext_glListDrawCommandsStatesClientNV,
    ext_glListParameterfSGIX,
    ext_glListParameterfvSGIX,
    ext_glListParameteriSGIX,
    ext_glListParameterivSGIX,
    ext_glLoadIdentityDeformationMapSGIX,
    ext_glLoadMatrixx,
    ext_glLoadMatrixxOES,
    ext_glLoadProgramNV,
    ext_glLoadTransposeMatrixd,
    ext_glLoadTransposeMatrixdARB,
    ext_glLoadTransposeMatrixf,
    ext_glLoadTransposeMatrixfARB,
    ext_glLoadTransposeMatrixxOES,
    ext_glLockArraysEXT,
    ext_glMTexCoord2fSGIS,
    ext_glMTexCoord2fvSGIS,
    ext_glMakeBufferNonResidentNV,
    ext_glMakeBufferResidentNV,
    ext_glMakeImageHandleNonResidentARB,
    ext_glMakeImageHandleNonResidentNV,
    ext_glMakeImageHandleResidentARB,
    ext_glMakeImageHandleResidentNV,
    ext_glMakeNamedBufferNonResidentNV,
    ext_glMakeNamedBufferResidentNV,
    ext_glMakeTextureHandleNonResidentARB,
    ext_glMakeTextureHandleNonResidentNV,
    ext_glMakeTextureHandleResidentARB,
    ext_glMakeTextureHandleResidentNV,
    ext_glMap1xOES,
    ext_glMap2xOES,
    ext_glMapBuffer,
    ext_glMapBufferARB,
    ext_glMapBufferRange,
    ext_glMapControlPointsNV,
    ext_glMapGrid1xOES,
    ext_glMapGrid2xOES,
    ext_glMapNamedBuffer,
    ext_glMapNamedBufferEXT,
    ext_glMapNamedBufferRange,
    ext_glMapNamedBufferRangeEXT,
    ext_glMapObjectBufferATI,
    ext_glMapParameterfvNV,
    ext_glMapParameterivNV,
    ext_glMapTexture2DINTEL,
    ext_glMapVertexAttrib1dAPPLE,
    ext_glMapVertexAttrib1fAPPLE,
    ext_glMapVertexAttrib2dAPPLE,
    ext_glMapVertexAttrib2fAPPLE,
    ext_glMaterialx,
    ext_glMaterialxOES,
    ext_glMaterialxv,
    ext_glMaterialxvOES,
    ext_glMatrixFrustumEXT,
    ext_glMatrixIndexPointerARB,
    ext_glMatrixIndexubvARB,
    ext_glMatrixIndexuivARB,
    ext_glMatrixIndexusvARB,
    ext_glMatrixLoad3x2fNV,
    ext_glMatrixLoad3x3fNV,
    ext_glMatrixLoadIdentityEXT,
    ext_glMatrixLoadTranspose3x3fNV,
    ext_glMatrixLoadTransposedEXT,
    ext_glMatrixLoadTransposefEXT,
    ext_glMatrixLoaddEXT,
    ext_glMatrixLoadfEXT,
    ext_glMatrixMult3x2fNV,
    ext_glMatrixMult3x3fNV,
    ext_glMatrixMultTranspose3x3fNV,
    ext_glMatrixMultTransposedEXT,
    ext_glMatrixMultTransposefEXT,
    ext_glMatrixMultdEXT,
    ext_glMatrixMultfEXT,
    ext_glMatrixOrthoEXT,
    ext_glMatrixPopEXT,
    ext_glMatrixPushEXT,
    ext_glMatrixRotatedEXT,
    ext_glMatrixRotatefEXT,
    ext_glMatrixScaledEXT,
    ext_glMatrixScalefEXT,
    ext_glMatrixTranslatedEXT,
    ext_glMatrixTranslatefEXT,
    ext_glMaxShaderCompilerThreadsARB,
    ext_glMaxShaderCompilerThreadsKHR,
    ext_glMemoryBarrier,
    ext_glMemoryBarrierByRegion,
    ext_glMemoryBarrierEXT,
    ext_glMemoryObjectParameterivEXT,
    ext_glMinSampleShading,
    ext_glMinSampleShadingARB,
    ext_glMinmax,
    ext_glMinmaxEXT,
    ext_glMultMatrixx,
    ext_glMultMatrixxOES,
    ext_glMultTransposeMatrixd,
    ext_glMultTransposeMatrixdARB,
    ext_glMultTransposeMatrixf,
    ext_glMultTransposeMatrixfARB,
    ext_glMultTransposeMatrixxOES,
    ext_glMultiDrawArrays,
    ext_glMultiDrawArraysEXT,
    ext_glMultiDrawArraysIndirect,
    ext_glMultiDrawArraysIndirectAMD,
    ext_glMultiDrawArraysIndirectBindlessCountNV,
    ext_glMultiDrawArraysIndirectBindlessNV,
    ext_glMultiDrawArraysIndirectCount,
    ext_glMultiDrawArraysIndirectCountARB,
    ext_glMultiDrawElementArrayAPPLE,
    ext_glMultiDrawElements,
    ext_glMultiDrawElementsBaseVertex,
    ext_glMultiDrawElementsEXT,
    ext_glMultiDrawElementsIndirect,
    ext_glMultiDrawElementsIndirectAMD,
    ext_glMultiDrawElementsIndirectBindlessCountNV,
    ext_glMultiDrawElementsIndirectBindlessNV,
    ext_glMultiDrawElementsIndirectCount,
    ext_glMultiDrawElementsIndirectCountARB,
    ext_glMultiDrawMeshTasksIndirectCountEXT,
    ext_glMultiDrawMeshTasksIndirectCountNV,
    ext_glMultiDrawMeshTasksIndirectEXT,
    ext_glMultiDrawMeshTasksIndirectNV,
    ext_glMultiDrawRangeElementArrayAPPLE,
    ext_glMultiModeDrawArraysIBM,
    ext_glMultiModeDrawElementsIBM,
    ext_glMultiTexBufferEXT,
    ext_glMultiTexCoord1bOES,
    ext_glMultiTexCoord1bvOES,
    ext_glMultiTexCoord1d,
    ext_glMultiTexCoord1dARB,
    ext_glMultiTexCoord1dSGIS,
    ext_glMultiTexCoord1dv,
    ext_glMultiTexCoord1dvARB,
    ext_glMultiTexCoord1dvSGIS,
    ext_glMultiTexCoord1f,
    ext_glMultiTexCoord1fARB,
    ext_glMultiTexCoord1fSGIS,
    ext_glMultiTexCoord1fv,
    ext_glMultiTexCoord1fvARB,
    ext_glMultiTexCoord1fvSGIS,
    ext_glMultiTexCoord1hNV,
    ext_glMultiTexCoord1hvNV,
    ext_glMultiTexCoord1i,
    ext_glMultiTexCoord1iARB,
    ext_glMultiTexCoord1iSGIS,
    ext_glMultiTexCoord1iv,
    ext_glMultiTexCoord1ivARB,
    ext_glMultiTexCoord1ivSGIS,
    ext_glMultiTexCoord1s,
    ext_glMultiTexCoord1sARB,
    ext_glMultiTexCoord1sSGIS,
    ext_glMultiTexCoord1sv,
    ext_glMultiTexCoord1svARB,
    ext_glMultiTexCoord1svSGIS,
    ext_glMultiTexCoord1xOES,
    ext_glMultiTexCoord1xvOES,
    ext_glMultiTexCoord2bOES,
    ext_glMultiTexCoord2bvOES,
    ext_glMultiTexCoord2d,
    ext_glMultiTexCoord2dARB,
    ext_glMultiTexCoord2dSGIS,
    ext_glMultiTexCoord2dv,
    ext_glMultiTexCoord2dvARB,
    ext_glMultiTexCoord2dvSGIS,
    ext_glMultiTexCoord2f,
    ext_glMultiTexCoord2fARB,
    ext_glMultiTexCoord2fSGIS,
    ext_glMultiTexCoord2fv,
    ext_glMultiTexCoord2fvARB,
    ext_glMultiTexCoord2fvSGIS,
    ext_glMultiTexCoord2hNV,
    ext_glMultiTexCoord2hvNV,
    ext_glMultiTexCoord2i,
    ext_glMultiTexCoord2iARB,
    ext_glMultiTexCoord2iSGIS,
    ext_glMultiTexCoord2iv,
    ext_glMultiTexCoord2ivARB,
    ext_glMultiTexCoord2ivSGIS,
    ext_glMultiTexCoord2s,
    ext_glMultiTexCoord2sARB,
    ext_glMultiTexCoord2sSGIS,
    ext_glMultiTexCoord2sv,
    ext_glMultiTexCoord2svARB,
    ext_glMultiTexCoord2svSGIS,
    ext_glMultiTexCoord2xOES,
    ext_glMultiTexCoord2xvOES,
    ext_glMultiTexCoord3bOES,
    ext_glMultiTexCoord3bvOES,
    ext_glMultiTexCoord3d,
    ext_glMultiTexCoord3dARB,
    ext_glMultiTexCoord3dSGIS,
    ext_glMultiTexCoord3dv,
    ext_glMultiTexCoord3dvARB,
    ext_glMultiTexCoord3dvSGIS,
    ext_glMultiTexCoord3f,
    ext_glMultiTexCoord3fARB,
    ext_glMultiTexCoord3fSGIS,
    ext_glMultiTexCoord3fv,
    ext_glMultiTexCoord3fvARB,
    ext_glMultiTexCoord3fvSGIS,
    ext_glMultiTexCoord3hNV,
    ext_glMultiTexCoord3hvNV,
    ext_glMultiTexCoord3i,
    ext_glMultiTexCoord3iARB,
    ext_glMultiTexCoord3iSGIS,
    ext_glMultiTexCoord3iv,
    ext_glMultiTexCoord3ivARB,
    ext_glMultiTexCoord3ivSGIS,
    ext_glMultiTexCoord3s,
    ext_glMultiTexCoord3sARB,
    ext_glMultiTexCoord3sSGIS,
    ext_glMultiTexCoord3sv,
    ext_glMultiTexCoord3svARB,
    ext_glMultiTexCoord3svSGIS,
    ext_glMultiTexCoord3xOES,
    ext_glMultiTexCoord3xvOES,
    ext_glMultiTexCoord4bOES,
    ext_glMultiTexCoord4bvOES,
    ext_glMultiTexCoord4d,
    ext_glMultiTexCoord4dARB,
    ext_glMultiTexCoord4dSGIS,
    ext_glMultiTexCoord4dv,
    ext_glMultiTexCoord4dvARB,
    ext_glMultiTexCoord4dvSGIS,
    ext_glMultiTexCoord4f,
    ext_glMultiTexCoord4fARB,
    ext_glMultiTexCoord4fSGIS,
    ext_glMultiTexCoord4fv,
    ext_glMultiTexCoord4fvARB,
    ext_glMultiTexCoord4fvSGIS,
    ext_glMultiTexCoord4hNV,
    ext_glMultiTexCoord4hvNV,
    ext_glMultiTexCoord4i,
    ext_glMultiTexCoord4iARB,
    ext_glMultiTexCoord4iSGIS,
    ext_glMultiTexCoord4iv,
    ext_glMultiTexCoord4ivARB,
    ext_glMultiTexCoord4ivSGIS,
    ext_glMultiTexCoord4s,
    ext_glMultiTexCoord4sARB,
    ext_glMultiTexCoord4sSGIS,
    ext_glMultiTexCoord4sv,
    ext_glMultiTexCoord4svARB,
    ext_glMultiTexCoord4svSGIS,
    ext_glMultiTexCoord4x,
    ext_glMultiTexCoord4xOES,
    ext_glMultiTexCoord4xvOES,
    ext_glMultiTexCoordP1ui,
    ext_glMultiTexCoordP1uiv,
    ext_glMultiTexCoordP2ui,
    ext_glMultiTexCoordP2uiv,
    ext_glMultiTexCoordP3ui,
    ext_glMultiTexCoordP3uiv,
    ext_glMultiTexCoordP4ui,
    ext_glMultiTexCoordP4uiv,
    ext_glMultiTexCoordPointerEXT,
    ext_glMultiTexCoordPointerSGIS,
    ext_glMultiTexEnvfEXT,
    ext_glMultiTexEnvfvEXT,
    ext_glMultiTexEnviEXT,
    ext_glMultiTexEnvivEXT,
    ext_glMultiTexGendEXT,
    ext_glMultiTexGendvEXT,
    ext_glMultiTexGenfEXT,
    ext_glMultiTexGenfvEXT,
    ext_glMultiTexGeniEXT,
    ext_glMultiTexGenivEXT,
    ext_glMultiTexImage1DEXT,
    ext_glMultiTexImage2DEXT,
    ext_glMultiTexImage3DEXT,
    ext_glMultiTexParameterIivEXT,
    ext_glMultiTexParameterIuivEXT,
    ext_glMultiTexParameterfEXT,
    ext_glMultiTexParameterfvEXT,
    ext_glMultiTexParameteriEXT,
    ext_glMultiTexParameterivEXT,
    ext_glMultiTexRenderbufferEXT,
    ext_glMultiTexSubImage1DEXT,
    ext_glMultiTexSubImage2DEXT,
    ext_glMultiTexSubImage3DEXT,
    ext_glMulticastBarrierNV,
    ext_glMulticastBlitFramebufferNV,
    ext_glMulticastBufferSubDataNV,
    ext_glMulticastCopyBufferSubDataNV,
    ext_glMulticastCopyImageSubDataNV,
    ext_glMulticastFramebufferSampleLocationsfvNV,
    ext_glMulticastGetQueryObjecti64vNV,
    ext_glMulticastGetQueryObjectivNV,
    ext_glMulticastGetQueryObjectui64vNV,
    ext_glMulticastGetQueryObjectuivNV,
    ext_glMulticastScissorArrayvNVX,
    ext_glMulticastViewportArrayvNVX,
    ext_glMulticastViewportPositionWScaleNVX,
    ext_glMulticastWaitSyncNV,
    ext_glNamedBufferAttachMemoryNV,
    ext_glNamedBufferData,
    ext_glNamedBufferDataEXT,
    ext_glNamedBufferPageCommitmentARB,
    ext_glNamedBufferPageCommitmentEXT,
    ext_glNamedBufferPageCommitmentMemNV,
    ext_glNamedBufferStorage,
    ext_glNamedBufferStorageEXT,
    ext_glNamedBufferStorageMemEXT,
    ext_glNamedBufferSubData,
    ext_glNamedBufferSubDataEXT,
    ext_glNamedCopyBufferSubDataEXT,
    ext_glNamedFramebufferDrawBuffer,
    ext_glNamedFramebufferDrawBuffers,
    ext_glNamedFramebufferParameteri,
    ext_glNamedFramebufferParameteriEXT,
    ext_glNamedFramebufferReadBuffer,
    ext_glNamedFramebufferRenderbuffer,
    ext_glNamedFramebufferRenderbufferEXT,
    ext_glNamedFramebufferSampleLocationsfvARB,
    ext_glNamedFramebufferSampleLocationsfvNV,
    ext_glNamedFramebufferSamplePositionsfvAMD,
    ext_glNamedFramebufferTexture,
    ext_glNamedFramebufferTexture1DEXT,
    ext_glNamedFramebufferTexture2DEXT,
    ext_glNamedFramebufferTexture3DEXT,
    ext_glNamedFramebufferTextureEXT,
    ext_glNamedFramebufferTextureFaceEXT,
    ext_glNamedFramebufferTextureLayer,
    ext_glNamedFramebufferTextureLayerEXT,
    ext_glNamedFramebufferTextureMultiviewOVR,
    ext_glNamedProgramLocalParameter4dEXT,
    ext_glNamedProgramLocalParameter4dvEXT,
    ext_glNamedProgramLocalParameter4fEXT,
    ext_glNamedProgramLocalParameter4fvEXT,
    ext_glNamedProgramLocalParameterI4iEXT,
    ext_glNamedProgramLocalParameterI4ivEXT,
    ext_glNamedProgramLocalParameterI4uiEXT,
    ext_glNamedProgramLocalParameterI4uivEXT,
    ext_glNamedProgramLocalParameters4fvEXT,
    ext_glNamedProgramLocalParametersI4ivEXT,
    ext_glNamedProgramLocalParametersI4uivEXT,
    ext_glNamedProgramStringEXT,
    ext_glNamedRenderbufferStorage,
    ext_glNamedRenderbufferStorageEXT,
    ext_glNamedRenderbufferStorageMultisample,
    ext_glNamedRenderbufferStorageMultisampleAdvancedAMD,
    ext_glNamedRenderbufferStorageMultisampleCoverageEXT,
    ext_glNamedRenderbufferStorageMultisampleEXT,
    ext_glNamedStringARB,
    ext_glNewBufferRegion,
    ext_glNewObjectBufferATI,
    ext_glNormal3fVertex3fSUN,
    ext_glNormal3fVertex3fvSUN,
    ext_glNormal3hNV,
    ext_glNormal3hvNV,
    ext_glNormal3x,
    ext_glNormal3xOES,
    ext_glNormal3xvOES,
    ext_glNormalFormatNV,
    ext_glNormalP3ui,
    ext_glNormalP3uiv,
    ext_glNormalPointerEXT,
    ext_glNormalPointerListIBM,
    ext_glNormalPointervINTEL,
    ext_glNormalStream3bATI,
    ext_glNormalStream3bvATI,
    ext_glNormalStream3dATI,
    ext_glNormalStream3dvATI,
    ext_glNormalStream3fATI,
    ext_glNormalStream3fvATI,
    ext_glNormalStream3iATI,
    ext_glNormalStream3ivATI,
    ext_glNormalStream3sATI,
    ext_glNormalStream3svATI,
    ext_glObjectLabel,
    ext_glObjectPtrLabel,
    ext_glObjectPurgeableAPPLE,
    ext_glObjectUnpurgeableAPPLE,
    ext_glOrthof,
    ext_glOrthofOES,
    ext_glOrthox,
    ext_glOrthoxOES,
    ext_glPNTrianglesfATI,
    ext_glPNTrianglesiATI,
    ext_glPassTexCoordATI,
    ext_glPassThroughxOES,
    ext_glPatchParameterfv,
    ext_glPatchParameteri,
    ext_glPathColorGenNV,
    ext_glPathCommandsNV,
    ext_glPathCoordsNV,
    ext_glPathCoverDepthFuncNV,
    ext_glPathDashArrayNV,
    ext_glPathFogGenNV,
    ext_glPathGlyphIndexArrayNV,
    ext_glPathGlyphIndexRangeNV,
    ext_glPathGlyphRangeNV,
    ext_glPathGlyphsNV,
    ext_glPathMemoryGlyphIndexArrayNV,
    ext_glPathParameterfNV,
    ext_glPathParameterfvNV,
    ext_glPathParameteriNV,
    ext_glPathParameterivNV,
    ext_glPathStencilDepthOffsetNV,
    ext_glPathStencilFuncNV,
    ext_glPathStringNV,
    ext_glPathSubCommandsNV,
    ext_glPathSubCoordsNV,
    ext_glPathTexGenNV,
    ext_glPauseTransformFeedback,
    ext_glPauseTransformFeedbackNV,
    ext_glPixelDataRangeNV,
    ext_glPixelMapx,
    ext_glPixelStorex,
    ext_glPixelTexGenParameterfSGIS,
    ext_glPixelTexGenParameterfvSGIS,
    ext_glPixelTexGenParameteriSGIS,
    ext_glPixelTexGenParameterivSGIS,
    ext_glPixelTexGenSGIX,
    ext_glPixelTransferxOES,
    ext_glPixelTransformParameterfEXT,
    ext_glPixelTransformParameterfvEXT,
    ext_glPixelTransformParameteriEXT,
    ext_glPixelTransformParameterivEXT,
    ext_glPixelZoomxOES,
    ext_glPointAlongPathNV,
    ext_glPointParameterf,
    ext_glPointParameterfARB,
    ext_glPointParameterfEXT,
    ext_glPointParameterfSGIS,
    ext_glPointParameterfv,
    ext_glPointParameterfvARB,
    ext_glPointParameterfvEXT,
    ext_glPointParameterfvSGIS,
    ext_glPointParameteri,
    ext_glPointParameteriNV,
    ext_glPointParameteriv,
    ext_glPointParameterivNV,
    ext_glPointParameterx,
    ext_glPointParameterxv,
    ext_glPointParameterxvOES,
    ext_glPointSizex,
    ext_glPointSizexOES,
    ext_glPollAsyncSGIX,
    ext_glPollInstrumentsSGIX,
    ext_glPolygonOffsetClamp,
    ext_glPolygonOffsetClampEXT,
    ext_glPolygonOffsetEXT,
    ext_glPolygonOffsetx,
    ext_glPolygonOffsetxOES,
    ext_glPopDebugGroup,
    ext_glPopGroupMarkerEXT,
    ext_glPresentFrameDualFillNV,
    ext_glPresentFrameKeyedNV,
    ext_glPrimitiveBoundingBox,
    ext_glPrimitiveBoundingBoxARB,
    ext_glPrimitiveRestartIndex,
    ext_glPrimitiveRestartIndexNV,
    ext_glPrimitiveRestartNV,
    ext_glPrioritizeTexturesEXT,
    ext_glPrioritizeTexturesxOES,
    ext_glProgramBinary,
    ext_glProgramBufferParametersIivNV,
    ext_glProgramBufferParametersIuivNV,
    ext_glProgramBufferParametersfvNV,
    ext_glProgramEnvParameter4dARB,
    ext_glProgramEnvParameter4dvARB,
    ext_glProgramEnvParameter4fARB,
    ext_glProgramEnvParameter4fvARB,
    ext_glProgramEnvParameterI4iNV,
    ext_glProgramEnvParameterI4ivNV,
    ext_glProgramEnvParameterI4uiNV,
    ext_glProgramEnvParameterI4uivNV,
    ext_glProgramEnvParameters4fvEXT,
    ext_glProgramEnvParametersI4ivNV,
    ext_glProgramEnvParametersI4uivNV,
    ext_glProgramLocalParameter4dARB,
    ext_glProgramLocalParameter4dvARB,
    ext_glProgramLocalParameter4fARB,
    ext_glProgramLocalParameter4fvARB,
    ext_glProgramLocalParameterI4iNV,
    ext_glProgramLocalParameterI4ivNV,
    ext_glProgramLocalParameterI4uiNV,
    ext_glProgramLocalParameterI4uivNV,
    ext_glProgramLocalParameters4fvEXT,
    ext_glProgramLocalParametersI4ivNV,
    ext_glProgramLocalParametersI4uivNV,
    ext_glProgramNamedParameter4dNV,
    ext_glProgramNamedParameter4dvNV,
    ext_glProgramNamedParameter4fNV,
    ext_glProgramNamedParameter4fvNV,
    ext_glProgramParameter4dNV,
    ext_glProgramParameter4dvNV,
    ext_glProgramParameter4fNV,
    ext_glProgramParameter4fvNV,
    ext_glProgramParameteri,
    ext_glProgramParameteriARB,
    ext_glProgramParameteriEXT,
    ext_glProgramParameters4dvNV,
    ext_glProgramParameters4fvNV,
    ext_glProgramPathFragmentInputGenNV,
    ext_glProgramStringARB,
    ext_glProgramSubroutineParametersuivNV,
    ext_glProgramUniform1d,
    ext_glProgramUniform1dEXT,
    ext_glProgramUniform1dv,
    ext_glProgramUniform1dvEXT,
    ext_glProgramUniform1f,
    ext_glProgramUniform1fEXT,
    ext_glProgramUniform1fv,
    ext_glProgramUniform1fvEXT,
    ext_glProgramUniform1i,
    ext_glProgramUniform1i64ARB,
    ext_glProgramUniform1i64NV,
    ext_glProgramUniform1i64vARB,
    ext_glProgramUniform1i64vNV,
    ext_glProgramUniform1iEXT,
    ext_glProgramUniform1iv,
    ext_glProgramUniform1ivEXT,
    ext_glProgramUniform1ui,
    ext_glProgramUniform1ui64ARB,
    ext_glProgramUniform1ui64NV,
    ext_glProgramUniform1ui64vARB,
    ext_glProgramUniform1ui64vNV,
    ext_glProgramUniform1uiEXT,
    ext_glProgramUniform1uiv,
    ext_glProgramUniform1uivEXT,
    ext_glProgramUniform2d,
    ext_glProgramUniform2dEXT,
    ext_glProgramUniform2dv,
    ext_glProgramUniform2dvEXT,
    ext_glProgramUniform2f,
    ext_glProgramUniform2fEXT,
    ext_glProgramUniform2fv,
    ext_glProgramUniform2fvEXT,
    ext_glProgramUniform2i,
    ext_glProgramUniform2i64ARB,
    ext_glProgramUniform2i64NV,
    ext_glProgramUniform2i64vARB,
    ext_glProgramUniform2i64vNV,
    ext_glProgramUniform2iEXT,
    ext_glProgramUniform2iv,
    ext_glProgramUniform2ivEXT,
    ext_glProgramUniform2ui,
    ext_glProgramUniform2ui64ARB,
    ext_glProgramUniform2ui64NV,
    ext_glProgramUniform2ui64vARB,
    ext_glProgramUniform2ui64vNV,
    ext_glProgramUniform2uiEXT,
    ext_glProgramUniform2uiv,
    ext_glProgramUniform2uivEXT,
    ext_glProgramUniform3d,
    ext_glProgramUniform3dEXT,
    ext_glProgramUniform3dv,
    ext_glProgramUniform3dvEXT,
    ext_glProgramUniform3f,
    ext_glProgramUniform3fEXT,
    ext_glProgramUniform3fv,
    ext_glProgramUniform3fvEXT,
    ext_glProgramUniform3i,
    ext_glProgramUniform3i64ARB,
    ext_glProgramUniform3i64NV,
    ext_glProgramUniform3i64vARB,
    ext_glProgramUniform3i64vNV,
    ext_glProgramUniform3iEXT,
    ext_glProgramUniform3iv,
    ext_glProgramUniform3ivEXT,
    ext_glProgramUniform3ui,
    ext_glProgramUniform3ui64ARB,
    ext_glProgramUniform3ui64NV,
    ext_glProgramUniform3ui64vARB,
    ext_glProgramUniform3ui64vNV,
    ext_glProgramUniform3uiEXT,
    ext_glProgramUniform3uiv,
    ext_glProgramUniform3uivEXT,
    ext_glProgramUniform4d,
    ext_glProgramUniform4dEXT,
    ext_glProgramUniform4dv,
    ext_glProgramUniform4dvEXT,
    ext_glProgramUniform4f,
    ext_glProgramUniform4fEXT,
    ext_glProgramUniform4fv,
    ext_glProgramUniform4fvEXT,
    ext_glProgramUniform4i,
    ext_glProgramUniform4i64ARB,
    ext_glProgramUniform4i64NV,
    ext_glProgramUniform4i64vARB,
    ext_glProgramUniform4i64vNV,
    ext_glProgramUniform4iEXT,
    ext_glProgramUniform4iv,
    ext_glProgramUniform4ivEXT,
    ext_glProgramUniform4ui,
    ext_glProgramUniform4ui64ARB,
    ext_glProgramUniform4ui64NV,
    ext_glProgramUniform4ui64vARB,
    ext_glProgramUniform4ui64vNV,
    ext_glProgramUniform4uiEXT,
    ext_glProgramUniform4uiv,
    ext_glProgramUniform4uivEXT,
    ext_glProgramUniformHandleui64ARB,
    ext_glProgramUniformHandleui64NV,
    ext_glProgramUniformHandleui64vARB,
    ext_glProgramUniformHandleui64vNV,
    ext_glProgramUniformMatrix2dv,
    ext_glProgramUniformMatrix2dvEXT,
    ext_glProgramUniformMatrix2fv,
    ext_glProgramUniformMatrix2fvEXT,
    ext_glProgramUniformMatrix2x3dv,
    ext_glProgramUniformMatrix2x3dvEXT,
    ext_glProgramUniformMatrix2x3fv,
    ext_glProgramUniformMatrix2x3fvEXT,
    ext_glProgramUniformMatrix2x4dv,
    ext_glProgramUniformMatrix2x4dvEXT,
    ext_glProgramUniformMatrix2x4fv,
    ext_glProgramUniformMatrix2x4fvEXT,
    ext_glProgramUniformMatrix3dv,
    ext_glProgramUniformMatrix3dvEXT,
    ext_glProgramUniformMatrix3fv,
    ext_glProgramUniformMatrix3fvEXT,
    ext_glProgramUniformMatrix3x2dv,
    ext_glProgramUniformMatrix3x2dvEXT,
    ext_glProgramUniformMatrix3x2fv,
    ext_glProgramUniformMatrix3x2fvEXT,
    ext_glProgramUniformMatrix3x4dv,
    ext_glProgramUniformMatrix3x4dvEXT,
    ext_glProgramUniformMatrix3x4fv,
    ext_glProgramUniformMatrix3x4fvEXT,
    ext_glProgramUniformMatrix4dv,
    ext_glProgramUniformMatrix4dvEXT,
    ext_glProgramUniformMatrix4fv,
    ext_glProgramUniformMatrix4fvEXT,
    ext_glProgramUniformMatrix4x2dv,
    ext_glProgramUniformMatrix4x2dvEXT,
    ext_glProgramUniformMatrix4x2fv,
    ext_glProgramUniformMatrix4x2fvEXT,
    ext_glProgramUniformMatrix4x3dv,
    ext_glProgramUniformMatrix4x3dvEXT,
    ext_glProgramUniformMatrix4x3fv,
    ext_glProgramUniformMatrix4x3fvEXT,
    ext_glProgramUniformui64NV,
    ext_glProgramUniformui64vNV,
    ext_glProgramVertexLimitNV,
    ext_glProvokingVertex,
    ext_glProvokingVertexEXT,
    ext_glPushClientAttribDefaultEXT,
    ext_glPushDebugGroup,
    ext_glPushGroupMarkerEXT,
    ext_glQueryCounter,
    ext_glQueryMatrixxOES,
    ext_glQueryObjectParameteruiAMD,
    ext_glQueryResourceNV,
    ext_glQueryResourceTagNV,
    ext_glRasterPos2xOES,
    ext_glRasterPos2xvOES,
    ext_glRasterPos3xOES,
    ext_glRasterPos3xvOES,
    ext_glRasterPos4xOES,
    ext_glRasterPos4xvOES,
    ext_glRasterSamplesEXT,
    ext_glReadBufferRegion,
    ext_glReadInstrumentsSGIX,
    ext_glReadnPixels,
    ext_glReadnPixelsARB,
    ext_glRectxOES,
    ext_glRectxvOES,
    ext_glReferencePlaneSGIX,
    ext_glReleaseKeyedMutexWin32EXT,
    ext_glReleaseShaderCompiler,
    ext_glRenderGpuMaskNV,
    ext_glRenderbufferStorage,
    ext_glRenderbufferStorageEXT,
    ext_glRenderbufferStorageMultisample,
    ext_glRenderbufferStorageMultisampleAdvancedAMD,
    ext_glRenderbufferStorageMultisampleCoverageNV,
    ext_glRenderbufferStorageMultisampleEXT,
    ext_glReplacementCodePointerSUN,
    ext_glReplacementCodeubSUN,
    ext_glReplacementCodeubvSUN,
    ext_glReplacementCodeuiColor3fVertex3fSUN,
    ext_glReplacementCodeuiColor3fVertex3fvSUN,
    ext_glReplacementCodeuiColor4fNormal3fVertex3fSUN,
    ext_glReplacementCodeuiColor4fNormal3fVertex3fvSUN,
    ext_glReplacementCodeuiColor4ubVertex3fSUN,
    ext_glReplacementCodeuiColor4ubVertex3fvSUN,
    ext_glReplacementCodeuiNormal3fVertex3fSUN,
    ext_glReplacementCodeuiNormal3fVertex3fvSUN,
    ext_glReplacementCodeuiSUN,
    ext_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN,
    ext_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN,
    ext_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN,
    ext_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN,
    ext_glReplacementCodeuiTexCoord2fVertex3fSUN,
    ext_glReplacementCodeuiTexCoord2fVertex3fvSUN,
    ext_glReplacementCodeuiVertex3fSUN,
    ext_glReplacementCodeuiVertex3fvSUN,
    ext_glReplacementCodeuivSUN,
    ext_glReplacementCodeusSUN,
    ext_glReplacementCodeusvSUN,
    ext_glRequestResidentProgramsNV,
    ext_glResetHistogram,
    ext_glResetHistogramEXT,
    ext_glResetMemoryObjectParameterNV,
    ext_glResetMinmax,
    ext_glResetMinmaxEXT,
    ext_glResizeBuffersMESA,
    ext_glResolveDepthValuesNV,
    ext_glResumeTransformFeedback,
    ext_glResumeTransformFeedbackNV,
    ext_glRotatex,
    ext_glRotatexOES,
    ext_glSampleCoverage,
    ext_glSampleCoverageARB,
    ext_glSampleCoveragex,
    ext_glSampleMapATI,
    ext_glSampleMaskEXT,
    ext_glSampleMaskIndexedNV,
    ext_glSampleMaskSGIS,
    ext_glSampleMaski,
    ext_glSamplePatternEXT,
    ext_glSamplePatternSGIS,
    ext_glSamplerParameterIiv,
    ext_glSamplerParameterIuiv,
    ext_glSamplerParameterf,
    ext_glSamplerParameterfv,
    ext_glSamplerParameteri,
    ext_glSamplerParameteriv,
    ext_glScalex,
    ext_glScalexOES,
    ext_glScissorArrayv,
    ext_glScissorExclusiveArrayvNV,
    ext_glScissorExclusiveNV,
    ext_glScissorIndexed,
    ext_glScissorIndexedv,
    ext_glSecondaryColor3b,
    ext_glSecondaryColor3bEXT,
    ext_glSecondaryColor3bv,
    ext_glSecondaryColor3bvEXT,
    ext_glSecondaryColor3d,
    ext_glSecondaryColor3dEXT,
    ext_glSecondaryColor3dv,
    ext_glSecondaryColor3dvEXT,
    ext_glSecondaryColor3f,
    ext_glSecondaryColor3fEXT,
    ext_glSecondaryColor3fv,
    ext_glSecondaryColor3fvEXT,
    ext_glSecondaryColor3hNV,
    ext_glSecondaryColor3hvNV,
    ext_glSecondaryColor3i,
    ext_glSecondaryColor3iEXT,
    ext_glSecondaryColor3iv,
    ext_glSecondaryColor3ivEXT,
    ext_glSecondaryColor3s,
    ext_glSecondaryColor3sEXT,
    ext_glSecondaryColor3sv,
    ext_glSecondaryColor3svEXT,
    ext_glSecondaryColor3ub,
    ext_glSecondaryColor3ubEXT,
    ext_glSecondaryColor3ubv,
    ext_glSecondaryColor3ubvEXT,
    ext_glSecondaryColor3ui,
    ext_glSecondaryColor3uiEXT,
    ext_glSecondaryColor3uiv,
    ext_glSecondaryColor3uivEXT,
    ext_glSecondaryColor3us,
    ext_glSecondaryColor3usEXT,
    ext_glSecondaryColor3usv,
    ext_glSecondaryColor3usvEXT,
    ext_glSecondaryColorFormatNV,
    ext_glSecondaryColorP3ui,
    ext_glSecondaryColorP3uiv,
    ext_glSecondaryColorPointer,
    ext_glSecondaryColorPointerEXT,
    ext_glSecondaryColorPointerListIBM,
    ext_glSelectPerfMonitorCountersAMD,
    ext_glSelectTextureCoordSetSGIS,
    ext_glSelectTextureSGIS,
    ext_glSemaphoreParameterivNV,
    ext_glSemaphoreParameterui64vEXT,
    ext_glSeparableFilter2D,
    ext_glSeparableFilter2DEXT,
    ext_glSetFenceAPPLE,
    ext_glSetFenceNV,
    ext_glSetFragmentShaderConstantATI,
    ext_glSetInvariantEXT,
    ext_glSetLocalConstantEXT,
    ext_glSetMultisamplefvAMD,
    ext_glShaderBinary,
    ext_glShaderOp1EXT,
    ext_glShaderOp2EXT,
    ext_glShaderOp3EXT,
    ext_glShaderSource,
    ext_glShaderSourceARB,
    ext_glShaderStorageBlockBinding,
    ext_glShadingRateCombinerOpsEXT,
    ext_glShadingRateEXT,
    ext_glShadingRateImageBarrierNV,
    ext_glShadingRateImagePaletteNV,
    ext_glShadingRateSampleOrderCustomNV,
    ext_glShadingRateSampleOrderNV,
    ext_glSharpenTexFuncSGIS,
    ext_glSignalSemaphoreEXT,
    ext_glSignalSemaphoreui64NVX,
    ext_glSignalVkFenceNV,
    ext_glSignalVkSemaphoreNV,
    ext_glSpecializeShader,
    ext_glSpecializeShaderARB,
    ext_glSpriteParameterfSGIX,
    ext_glSpriteParameterfvSGIX,
    ext_glSpriteParameteriSGIX,
    ext_glSpriteParameterivSGIX,
    ext_glStartInstrumentsSGIX,
    ext_glStateCaptureNV,
    ext_glStencilClearTagEXT,
    ext_glStencilFillPathInstancedNV,
    ext_glStencilFillPathNV,
    ext_glStencilFuncSeparate,
    ext_glStencilFuncSeparateATI,
    ext_glStencilMaskSeparate,
    ext_glStencilOpSeparate,
    ext_glStencilOpSeparateATI,
    ext_glStencilOpValueAMD,
    ext_glStencilStrokePathInstancedNV,
    ext_glStencilStrokePathNV,
    ext_glStencilThenCoverFillPathInstancedNV,
    ext_glStencilThenCoverFillPathNV,
    ext_glStencilThenCoverStrokePathInstancedNV,
    ext_glStencilThenCoverStrokePathNV,
    ext_glStopInstrumentsSGIX,
    ext_glStringMarkerGREMEDY,
    ext_glSubpixelPrecisionBiasNV,
    ext_glSwizzleEXT,
    ext_glSyncTextureINTEL,
    ext_glTagSampleBufferSGIX,
    ext_glTangent3bEXT,
    ext_glTangent3bvEXT,
    ext_glTangent3dEXT,
    ext_glTangent3dvEXT,
    ext_glTangent3fEXT,
    ext_glTangent3fvEXT,
    ext_glTangent3iEXT,
    ext_glTangent3ivEXT,
    ext_glTangent3sEXT,
    ext_glTangent3svEXT,
    ext_glTangentPointerEXT,
    ext_glTbufferMask3DFX,
    ext_glTessellationFactorAMD,
    ext_glTessellationModeAMD,
    ext_glTestFenceAPPLE,
    ext_glTestFenceNV,
    ext_glTestObjectAPPLE,
    ext_glTexAttachMemoryNV,
    ext_glTexBuffer,
    ext_glTexBufferARB,
    ext_glTexBufferEXT,
    ext_glTexBufferRange,
    ext_glTexBumpParameterfvATI,
    ext_glTexBumpParameterivATI,
    ext_glTexCoord1bOES,
    ext_glTexCoord1bvOES,
    ext_glTexCoord1hNV,
    ext_glTexCoord1hvNV,
    ext_glTexCoord1xOES,
    ext_glTexCoord1xvOES,
    ext_glTexCoord2bOES,
    ext_glTexCoord2bvOES,
    ext_glTexCoord2fColor3fVertex3fSUN,
    ext_glTexCoord2fColor3fVertex3fvSUN,
    ext_glTexCoord2fColor4fNormal3fVertex3fSUN,
    ext_glTexCoord2fColor4fNormal3fVertex3fvSUN,
    ext_glTexCoord2fColor4ubVertex3fSUN,
    ext_glTexCoord2fColor4ubVertex3fvSUN,
    ext_glTexCoord2fNormal3fVertex3fSUN,
    ext_glTexCoord2fNormal3fVertex3fvSUN,
    ext_glTexCoord2fVertex3fSUN,
    ext_glTexCoord2fVertex3fvSUN,
    ext_glTexCoord2hNV,
    ext_glTexCoord2hvNV,
    ext_glTexCoord2xOES,
    ext_glTexCoord2xvOES,
    ext_glTexCoord3bOES,
    ext_glTexCoord3bvOES,
    ext_glTexCoord3hNV,
    ext_glTexCoord3hvNV,
    ext_glTexCoord3xOES,
    ext_glTexCoord3xvOES,
    ext_glTexCoord4bOES,
    ext_glTexCoord4bvOES,
    ext_glTexCoord4fColor4fNormal3fVertex4fSUN,
    ext_glTexCoord4fColor4fNormal3fVertex4fvSUN,
    ext_glTexCoord4fVertex4fSUN,
    ext_glTexCoord4fVertex4fvSUN,
    ext_glTexCoord4hNV,
    ext_glTexCoord4hvNV,
    ext_glTexCoord4xOES,
    ext_glTexCoord4xvOES,
    ext_glTexCoordFormatNV,
    ext_glTexCoordP1ui,
    ext_glTexCoordP1uiv,
    ext_glTexCoordP2ui,
    ext_glTexCoordP2uiv,
    ext_glTexCoordP3ui,
    ext_glTexCoordP3uiv,
    ext_glTexCoordP4ui,
    ext_glTexCoordP4uiv,
    ext_glTexCoordPointerEXT,
    ext_glTexCoordPointerListIBM,
    ext_glTexCoordPointervINTEL,
    ext_glTexEnvx,
    ext_glTexEnvxOES,
    ext_glTexEnvxv,
    ext_glTexEnvxvOES,
    ext_glTexFilterFuncSGIS,
    ext_glTexGenxOES,
    ext_glTexGenxvOES,
    ext_glTexImage2DMultisample,
    ext_glTexImage2DMultisampleCoverageNV,
    ext_glTexImage3D,
    ext_glTexImage3DEXT,
    ext_glTexImage3DMultisample,
    ext_glTexImage3DMultisampleCoverageNV,
    ext_glTexImage4DSGIS,
    ext_glTexPageCommitmentARB,
    ext_glTexPageCommitmentMemNV,
    ext_glTexParameterIiv,
    ext_glTexParameterIivEXT,
    ext_glTexParameterIuiv,
    ext_glTexParameterIuivEXT,
    ext_glTexParameterx,
    ext_glTexParameterxOES,
    ext_glTexParameterxv,
    ext_glTexParameterxvOES,
    ext_glTexRenderbufferNV,
    ext_glTexStorage1D,
    ext_glTexStorage1DEXT,
    ext_glTexStorage2D,
    ext_glTexStorage2DEXT,
    ext_glTexStorage2DMultisample,
    ext_glTexStorage3D,
    ext_glTexStorage3DEXT,
    ext_glTexStorage3DMultisample,
    ext_glTexStorageMem1DEXT,
    ext_glTexStorageMem2DEXT,
    ext_glTexStorageMem2DMultisampleEXT,
    ext_glTexStorageMem3DEXT,
    ext_glTexStorageMem3DMultisampleEXT,
    ext_glTexStorageSparseAMD,
    ext_glTexSubImage1DEXT,
    ext_glTexSubImage2DEXT,
    ext_glTexSubImage3D,
    ext_glTexSubImage3DEXT,
    ext_glTexSubImage4DSGIS,
    ext_glTextureAttachMemoryNV,
    ext_glTextureBarrier,
    ext_glTextureBarrierNV,
    ext_glTextureBuffer,
    ext_glTextureBufferEXT,
    ext_glTextureBufferRange,
    ext_glTextureBufferRangeEXT,
    ext_glTextureColorMaskSGIS,
    ext_glTextureImage1DEXT,
    ext_glTextureImage2DEXT,
    ext_glTextureImage2DMultisampleCoverageNV,
    ext_glTextureImage2DMultisampleNV,
    ext_glTextureImage3DEXT,
    ext_glTextureImage3DMultisampleCoverageNV,
    ext_glTextureImage3DMultisampleNV,
    ext_glTextureLightEXT,
    ext_glTextureMaterialEXT,
    ext_glTextureNormalEXT,
    ext_glTexturePageCommitmentEXT,
    ext_glTexturePageCommitmentMemNV,
    ext_glTextureParameterIiv,
    ext_glTextureParameterIivEXT,
    ext_glTextureParameterIuiv,
    ext_glTextureParameterIuivEXT,
    ext_glTextureParameterf,
    ext_glTextureParameterfEXT,
    ext_glTextureParameterfv,
    ext_glTextureParameterfvEXT,
    ext_glTextureParameteri,
    ext_glTextureParameteriEXT,
    ext_glTextureParameteriv,
    ext_glTextureParameterivEXT,
    ext_glTextureRangeAPPLE,
    ext_glTextureRenderbufferEXT,
    ext_glTextureStorage1D,
    ext_glTextureStorage1DEXT,
    ext_glTextureStorage2D,
    ext_glTextureStorage2DEXT,
    ext_glTextureStorage2DMultisample,
    ext_glTextureStorage2DMultisampleEXT,
    ext_glTextureStorage3D,
    ext_glTextureStorage3DEXT,
    ext_glTextureStorage3DMultisample,
    ext_glTextureStorage3DMultisampleEXT,
    ext_glTextureStorageMem1DEXT,
    ext_glTextureStorageMem2DEXT,
    ext_glTextureStorageMem2DMultisampleEXT,
    ext_glTextureStorageMem3DEXT,
    ext_glTextureStorageMem3DMultisampleEXT,
    ext_glTextureStorageSparseAMD,
    ext_glTextureSubImage1D,
    ext_glTextureSubImage1DEXT,
    ext_glTextureSubImage2D,
    ext_glTextureSubImage2DEXT,
    ext_glTextureSubImage3D,
    ext_glTextureSubImage3DEXT,
    ext_glTextureView,
    ext_glTrackMatrixNV,
    ext_glTransformFeedbackAttribsNV,
    ext_glTransformFeedbackBufferBase,
    ext_glTransformFeedbackBufferRange,
    ext_glTransformFeedbackStreamAttribsNV,
    ext_glTransformFeedbackVaryings,
    ext_glTransformFeedbackVaryingsEXT,
    ext_glTransformFeedbackVaryingsNV,
    ext_glTransformPathNV,
    ext_glTranslatex,
    ext_glTranslatexOES,
    ext_glUniform1d,
    ext_glUniform1dv,
    ext_glUniform1f,
    ext_glUniform1fARB,
    ext_glUniform1fv,
    ext_glUniform1fvARB,
    ext_glUniform1i,
    ext_glUniform1i64ARB,
    ext_glUniform1i64NV,
    ext_glUniform1i64vARB,
    ext_glUniform1i64vNV,
    ext_glUniform1iARB,
    ext_glUniform1iv,
    ext_glUniform1ivARB,
    ext_glUniform1ui,
    ext_glUniform1ui64ARB,
    ext_glUniform1ui64NV,
    ext_glUniform1ui64vARB,
    ext_glUniform1ui64vNV,
    ext_glUniform1uiEXT,
    ext_glUniform1uiv,
    ext_glUniform1uivEXT,
    ext_glUniform2d,
    ext_glUniform2dv,
    ext_glUniform2f,
    ext_glUniform2fARB,
    ext_glUniform2fv,
    ext_glUniform2fvARB,
    ext_glUniform2i,
    ext_glUniform2i64ARB,
    ext_glUniform2i64NV,
    ext_glUniform2i64vARB,
    ext_glUniform2i64vNV,
    ext_glUniform2iARB,
    ext_glUniform2iv,
    ext_glUniform2ivARB,
    ext_glUniform2ui,
    ext_glUniform2ui64ARB,
    ext_glUniform2ui64NV,
    ext_glUniform2ui64vARB,
    ext_glUniform2ui64vNV,
    ext_glUniform2uiEXT,
    ext_glUniform2uiv,
    ext_glUniform2uivEXT,
    ext_glUniform3d,
    ext_glUniform3dv,
    ext_glUniform3f,
    ext_glUniform3fARB,
    ext_glUniform3fv,
    ext_glUniform3fvARB,
    ext_glUniform3i,
    ext_glUniform3i64ARB,
    ext_glUniform3i64NV,
    ext_glUniform3i64vARB,
    ext_glUniform3i64vNV,
    ext_glUniform3iARB,
    ext_glUniform3iv,
    ext_glUniform3ivARB,
    ext_glUniform3ui,
    ext_glUniform3ui64ARB,
    ext_glUniform3ui64NV,
    ext_glUniform3ui64vARB,
    ext_glUniform3ui64vNV,
    ext_glUniform3uiEXT,
    ext_glUniform3uiv,
    ext_glUniform3uivEXT,
    ext_glUniform4d,
    ext_glUniform4dv,
    ext_glUniform4f,
    ext_glUniform4fARB,
    ext_glUniform4fv,
    ext_glUniform4fvARB,
    ext_glUniform4i,
    ext_glUniform4i64ARB,
    ext_glUniform4i64NV,
    ext_glUniform4i64vARB,
    ext_glUniform4i64vNV,
    ext_glUniform4iARB,
    ext_glUniform4iv,
    ext_glUniform4ivARB,
    ext_glUniform4ui,
    ext_glUniform4ui64ARB,
    ext_glUniform4ui64NV,
    ext_glUniform4ui64vARB,
    ext_glUniform4ui64vNV,
    ext_glUniform4uiEXT,
    ext_glUniform4uiv,
    ext_glUniform4uivEXT,
    ext_glUniformBlockBinding,
    ext_glUniformBufferEXT,
    ext_glUniformHandleui64ARB,
    ext_glUniformHandleui64NV,
    ext_glUniformHandleui64vARB,
    ext_glUniformHandleui64vNV,
    ext_glUniformMatrix2dv,
    ext_glUniformMatrix2fv,
    ext_glUniformMatrix2fvARB,
    ext_glUniformMatrix2x3dv,
    ext_glUniformMatrix2x3fv,
    ext_glUniformMatrix2x4dv,
    ext_glUniformMatrix2x4fv,
    ext_glUniformMatrix3dv,
    ext_glUniformMatrix3fv,
    ext_glUniformMatrix3fvARB,
    ext_glUniformMatrix3x2dv,
    ext_glUniformMatrix3x2fv,
    ext_glUniformMatrix3x4dv,
    ext_glUniformMatrix3x4fv,
    ext_glUniformMatrix4dv,
    ext_glUniformMatrix4fv,
    ext_glUniformMatrix4fvARB,
    ext_glUniformMatrix4x2dv,
    ext_glUniformMatrix4x2fv,
    ext_glUniformMatrix4x3dv,
    ext_glUniformMatrix4x3fv,
    ext_glUniformSubroutinesuiv,
    ext_glUniformui64NV,
    ext_glUniformui64vNV,
    ext_glUnlockArraysEXT,
    ext_glUnmapBuffer,
    ext_glUnmapBufferARB,
    ext_glUnmapNamedBuffer,
    ext_glUnmapNamedBufferEXT,
    ext_glUnmapObjectBufferATI,
    ext_glUnmapTexture2DINTEL,
    ext_glUpdateObjectBufferATI,
    ext_glUploadGpuMaskNVX,
    ext_glUseProgram,
    ext_glUseProgramObjectARB,
    ext_glUseProgramStages,
    ext_glUseShaderProgramEXT,
    ext_glVDPAUFiniNV,
    ext_glVDPAUGetSurfaceivNV,
    ext_glVDPAUInitNV,
    ext_glVDPAUIsSurfaceNV,
    ext_glVDPAUMapSurfacesNV,
    ext_glVDPAURegisterOutputSurfaceNV,
    ext_glVDPAURegisterVideoSurfaceNV,
    ext_glVDPAURegisterVideoSurfaceWithPictureStructureNV,
    ext_glVDPAUSurfaceAccessNV,
    ext_glVDPAUUnmapSurfacesNV,
    ext_glVDPAUUnregisterSurfaceNV,
    ext_glValidateProgram,
    ext_glValidateProgramARB,
    ext_glValidateProgramPipeline,
    ext_glVariantArrayObjectATI,
    ext_glVariantPointerEXT,
    ext_glVariantbvEXT,
    ext_glVariantdvEXT,
    ext_glVariantfvEXT,
    ext_glVariantivEXT,
    ext_glVariantsvEXT,
    ext_glVariantubvEXT,
    ext_glVariantuivEXT,
    ext_glVariantusvEXT,
    ext_glVertex2bOES,
    ext_glVertex2bvOES,
    ext_glVertex2hNV,
    ext_glVertex2hvNV,
    ext_glVertex2xOES,
    ext_glVertex2xvOES,
    ext_glVertex3bOES,
    ext_glVertex3bvOES,
    ext_glVertex3hNV,
    ext_glVertex3hvNV,
    ext_glVertex3xOES,
    ext_glVertex3xvOES,
    ext_glVertex4bOES,
    ext_glVertex4bvOES,
    ext_glVertex4hNV,
    ext_glVertex4hvNV,
    ext_glVertex4xOES,
    ext_glVertex4xvOES,
    ext_glVertexArrayAttribBinding,
    ext_glVertexArrayAttribFormat,
    ext_glVertexArrayAttribIFormat,
    ext_glVertexArrayAttribLFormat,
    ext_glVertexArrayBindVertexBufferEXT,
    ext_glVertexArrayBindingDivisor,
    ext_glVertexArrayColorOffsetEXT,
    ext_glVertexArrayEdgeFlagOffsetEXT,
    ext_glVertexArrayElementBuffer,
    ext_glVertexArrayFogCoordOffsetEXT,
    ext_glVertexArrayIndexOffsetEXT,
    ext_glVertexArrayMultiTexCoordOffsetEXT,
    ext_glVertexArrayNormalOffsetEXT,
    ext_glVertexArrayParameteriAPPLE,
    ext_glVertexArrayRangeAPPLE,
    ext_glVertexArrayRangeNV,
    ext_glVertexArraySecondaryColorOffsetEXT,
    ext_glVertexArrayTexCoordOffsetEXT,
    ext_glVertexArrayVertexAttribBindingEXT,
    ext_glVertexArrayVertexAttribDivisorEXT,
    ext_glVertexArrayVertexAttribFormatEXT,
    ext_glVertexArrayVertexAttribIFormatEXT,
    ext_glVertexArrayVertexAttribIOffsetEXT,
    ext_glVertexArrayVertexAttribLFormatEXT,
    ext_glVertexArrayVertexAttribLOffsetEXT,
    ext_glVertexArrayVertexAttribOffsetEXT,
    ext_glVertexArrayVertexBindingDivisorEXT,
    ext_glVertexArrayVertexBuffer,
    ext_glVertexArrayVertexBuffers,
    ext_glVertexArrayVertexOffsetEXT,
    ext_glVertexAttrib1d,
    ext_glVertexAttrib1dARB,
    ext_glVertexAttrib1dNV,
    ext_glVertexAttrib1dv,
    ext_glVertexAttrib1dvARB,
    ext_glVertexAttrib1dvNV,
    ext_glVertexAttrib1f,
    ext_glVertexAttrib1fARB,
    ext_glVertexAttrib1fNV,
    ext_glVertexAttrib1fv,
    ext_glVertexAttrib1fvARB,
    ext_glVertexAttrib1fvNV,
    ext_glVertexAttrib1hNV,
    ext_glVertexAttrib1hvNV,
    ext_glVertexAttrib1s,
    ext_glVertexAttrib1sARB,
    ext_glVertexAttrib1sNV,
    ext_glVertexAttrib1sv,
    ext_glVertexAttrib1svARB,
    ext_glVertexAttrib1svNV,
    ext_glVertexAttrib2d,
    ext_glVertexAttrib2dARB,
    ext_glVertexAttrib2dNV,
    ext_glVertexAttrib2dv,
    ext_glVertexAttrib2dvARB,
    ext_glVertexAttrib2dvNV,
    ext_glVertexAttrib2f,
    ext_glVertexAttrib2fARB,
    ext_glVertexAttrib2fNV,
    ext_glVertexAttrib2fv,
    ext_glVertexAttrib2fvARB,
    ext_glVertexAttrib2fvNV,
    ext_glVertexAttrib2hNV,
    ext_glVertexAttrib2hvNV,
    ext_glVertexAttrib2s,
    ext_glVertexAttrib2sARB,
    ext_glVertexAttrib2sNV,
    ext_glVertexAttrib2sv,
    ext_glVertexAttrib2svARB,
    ext_glVertexAttrib2svNV,
    ext_glVertexAttrib3d,
    ext_glVertexAttrib3dARB,
    ext_glVertexAttrib3dNV,
    ext_glVertexAttrib3dv,
    ext_glVertexAttrib3dvARB,
    ext_glVertexAttrib3dvNV,
    ext_glVertexAttrib3f,
    ext_glVertexAttrib3fARB,
    ext_glVertexAttrib3fNV,
    ext_glVertexAttrib3fv,
    ext_glVertexAttrib3fvARB,
    ext_glVertexAttrib3fvNV,
    ext_glVertexAttrib3hNV,
    ext_glVertexAttrib3hvNV,
    ext_glVertexAttrib3s,
    ext_glVertexAttrib3sARB,
    ext_glVertexAttrib3sNV,
    ext_glVertexAttrib3sv,
    ext_glVertexAttrib3svARB,
    ext_glVertexAttrib3svNV,
    ext_glVertexAttrib4Nbv,
    ext_glVertexAttrib4NbvARB,
    ext_glVertexAttrib4Niv,
    ext_glVertexAttrib4NivARB,
    ext_glVertexAttrib4Nsv,
    ext_glVertexAttrib4NsvARB,
    ext_glVertexAttrib4Nub,
    ext_glVertexAttrib4NubARB,
    ext_glVertexAttrib4Nubv,
    ext_glVertexAttrib4NubvARB,
    ext_glVertexAttrib4Nuiv,
    ext_glVertexAttrib4NuivARB,
    ext_glVertexAttrib4Nusv,
    ext_glVertexAttrib4NusvARB,
    ext_glVertexAttrib4bv,
    ext_glVertexAttrib4bvARB,
    ext_glVertexAttrib4d,
    ext_glVertexAttrib4dARB,
    ext_glVertexAttrib4dNV,
    ext_glVertexAttrib4dv,
    ext_glVertexAttrib4dvARB,
    ext_glVertexAttrib4dvNV,
    ext_glVertexAttrib4f,
    ext_glVertexAttrib4fARB,
    ext_glVertexAttrib4fNV,
    ext_glVertexAttrib4fv,
    ext_glVertexAttrib4fvARB,
    ext_glVertexAttrib4fvNV,
    ext_glVertexAttrib4hNV,
    ext_glVertexAttrib4hvNV,
    ext_glVertexAttrib4iv,
    ext_glVertexAttrib4ivARB,
    ext_glVertexAttrib4s,
    ext_glVertexAttrib4sARB,
    ext_glVertexAttrib4sNV,
    ext_glVertexAttrib4sv,
    ext_glVertexAttrib4svARB,
    ext_glVertexAttrib4svNV,
    ext_glVertexAttrib4ubNV,
    ext_glVertexAttrib4ubv,
    ext_glVertexAttrib4ubvARB,
    ext_glVertexAttrib4ubvNV,
    ext_glVertexAttrib4uiv,
    ext_glVertexAttrib4uivARB,
    ext_glVertexAttrib4usv,
    ext_glVertexAttrib4usvARB,
    ext_glVertexAttribArrayObjectATI,
    ext_glVertexAttribBinding,
    ext_glVertexAttribDivisor,
    ext_glVertexAttribDivisorARB,
    ext_glVertexAttribFormat,
    ext_glVertexAttribFormatNV,
    ext_glVertexAttribI1i,
    ext_glVertexAttribI1iEXT,
    ext_glVertexAttribI1iv,
    ext_glVertexAttribI1ivEXT,
    ext_glVertexAttribI1ui,
    ext_glVertexAttribI1uiEXT,
    ext_glVertexAttribI1uiv,
    ext_glVertexAttribI1uivEXT,
    ext_glVertexAttribI2i,
    ext_glVertexAttribI2iEXT,
    ext_glVertexAttribI2iv,
    ext_glVertexAttribI2ivEXT,
    ext_glVertexAttribI2ui,
    ext_glVertexAttribI2uiEXT,
    ext_glVertexAttribI2uiv,
    ext_glVertexAttribI2uivEXT,
    ext_glVertexAttribI3i,
    ext_glVertexAttribI3iEXT,
    ext_glVertexAttribI3iv,
    ext_glVertexAttribI3ivEXT,
    ext_glVertexAttribI3ui,
    ext_glVertexAttribI3uiEXT,
    ext_glVertexAttribI3uiv,
    ext_glVertexAttribI3uivEXT,
    ext_glVertexAttribI4bv,
    ext_glVertexAttribI4bvEXT,
    ext_glVertexAttribI4i,
    ext_glVertexAttribI4iEXT,
    ext_glVertexAttribI4iv,
    ext_glVertexAttribI4ivEXT,
    ext_glVertexAttribI4sv,
    ext_glVertexAttribI4svEXT,
    ext_glVertexAttribI4ubv,
    ext_glVertexAttribI4ubvEXT,
    ext_glVertexAttribI4ui,
    ext_glVertexAttribI4uiEXT,
    ext_glVertexAttribI4uiv,
    ext_glVertexAttribI4uivEXT,
    ext_glVertexAttribI4usv,
    ext_glVertexAttribI4usvEXT,
    ext_glVertexAttribIFormat,
    ext_glVertexAttribIFormatNV,
    ext_glVertexAttribIPointer,
    ext_glVertexAttribIPointerEXT,
    ext_glVertexAttribL1d,
    ext_glVertexAttribL1dEXT,
    ext_glVertexAttribL1dv,
    ext_glVertexAttribL1dvEXT,
    ext_glVertexAttribL1i64NV,
    ext_glVertexAttribL1i64vNV,
    ext_glVertexAttribL1ui64ARB,
    ext_glVertexAttribL1ui64NV,
    ext_glVertexAttribL1ui64vARB,
    ext_glVertexAttribL1ui64vNV,
    ext_glVertexAttribL2d,
    ext_glVertexAttribL2dEXT,
    ext_glVertexAttribL2dv,
    ext_glVertexAttribL2dvEXT,
    ext_glVertexAttribL2i64NV,
    ext_glVertexAttribL2i64vNV,
    ext_glVertexAttribL2ui64NV,
    ext_glVertexAttribL2ui64vNV,
    ext_glVertexAttribL3d,
    ext_glVertexAttribL3dEXT,
    ext_glVertexAttribL3dv,
    ext_glVertexAttribL3dvEXT,
    ext_glVertexAttribL3i64NV,
    ext_glVertexAttribL3i64vNV,
    ext_glVertexAttribL3ui64NV,
    ext_glVertexAttribL3ui64vNV,
    ext_glVertexAttribL4d,
    ext_glVertexAttribL4dEXT,
    ext_glVertexAttribL4dv,
    ext_glVertexAttribL4dvEXT,
    ext_glVertexAttribL4i64NV,
    ext_glVertexAttribL4i64vNV,
    ext_glVertexAttribL4ui64NV,
    ext_glVertexAttribL4ui64vNV,
    ext_glVertexAttribLFormat,
    ext_glVertexAttribLFormatNV,
    ext_glVertexAttribLPointer,
    ext_glVertexAttribLPointerEXT,
    ext_glVertexAttribP1ui,
    ext_glVertexAttribP1uiv,
    ext_glVertexAttribP2ui,
    ext_glVertexAttribP2uiv,
    ext_glVertexAttribP3ui,
    ext_glVertexAttribP3uiv,
    ext_glVertexAttribP4ui,
    ext_glVertexAttribP4uiv,
    ext_glVertexAttribParameteriAMD,
    ext_glVertexAttribPointer,
    ext_glVertexAttribPointerARB,
    ext_glVertexAttribPointerNV,
    ext_glVertexAttribs1dvNV,
    ext_glVertexAttribs1fvNV,
    ext_glVertexAttribs1hvNV,
    ext_glVertexAttribs1svNV,
    ext_glVertexAttribs2dvNV,
    ext_glVertexAttribs2fvNV,
    ext_glVertexAttribs2hvNV,
    ext_glVertexAttribs2svNV,
    ext_glVertexAttribs3dvNV,
    ext_glVertexAttribs3fvNV,
    ext_glVertexAttribs3hvNV,
    ext_glVertexAttribs3svNV,
    ext_glVertexAttribs4dvNV,
    ext_glVertexAttribs4fvNV,
    ext_glVertexAttribs4hvNV,
    ext_glVertexAttribs4svNV,
    ext_glVertexAttribs4ubvNV,
    ext_glVertexBindingDivisor,
    ext_glVertexBlendARB,
    ext_glVertexBlendEnvfATI,
    ext_glVertexBlendEnviATI,
    ext_glVertexFormatNV,
    ext_glVertexP2ui,
    ext_glVertexP2uiv,
    ext_glVertexP3ui,
    ext_glVertexP3uiv,
    ext_glVertexP4ui,
    ext_glVertexP4uiv,
    ext_glVertexPointerEXT,
    ext_glVertexPointerListIBM,
    ext_glVertexPointervINTEL,
    ext_glVertexStream1dATI,
    ext_glVertexStream1dvATI,
    ext_glVertexStream1fATI,
    ext_glVertexStream1fvATI,
    ext_glVertexStream1iATI,
    ext_glVertexStream1ivATI,
    ext_glVertexStream1sATI,
    ext_glVertexStream1svATI,
    ext_glVertexStream2dATI,
    ext_glVertexStream2dvATI,
    ext_glVertexStream2fATI,
    ext_glVertexStream2fvATI,
    ext_glVertexStream2iATI,
    ext_glVertexStream2ivATI,
    ext_glVertexStream2sATI,
    ext_glVertexStream2svATI,
    ext_glVertexStream3dATI,
    ext_glVertexStream3dvATI,
    ext_glVertexStream3fATI,
    ext_glVertexStream3fvATI,
    ext_glVertexStream3iATI,
    ext_glVertexStream3ivATI,
    ext_glVertexStream3sATI,
    ext_glVertexStream3svATI,
    ext_glVertexStream4dATI,
    ext_glVertexStream4dvATI,
    ext_glVertexStream4fATI,
    ext_glVertexStream4fvATI,
    ext_glVertexStream4iATI,
    ext_glVertexStream4ivATI,
    ext_glVertexStream4sATI,
    ext_glVertexStream4svATI,
    ext_glVertexWeightPointerEXT,
    ext_glVertexWeightfEXT,
    ext_glVertexWeightfvEXT,
    ext_glVertexWeighthNV,
    ext_glVertexWeighthvNV,
    ext_glVideoCaptureNV,
    ext_glVideoCaptureStreamParameterdvNV,
    ext_glVideoCaptureStreamParameterfvNV,
    ext_glVideoCaptureStreamParameterivNV,
    ext_glViewportArrayv,
    ext_glViewportIndexedf,
    ext_glViewportIndexedfv,
    ext_glViewportPositionWScaleNV,
    ext_glViewportSwizzleNV,
    ext_glWaitSemaphoreEXT,
    ext_glWaitSemaphoreui64NVX,
    ext_glWaitSync,
    ext_glWaitVkSemaphoreNV,
    ext_glWeightPathsNV,
    ext_glWeightPointerARB,
    ext_glWeightbvARB,
    ext_glWeightdvARB,
    ext_glWeightfvARB,
    ext_glWeightivARB,
    ext_glWeightsvARB,
    ext_glWeightubvARB,
    ext_glWeightuivARB,
    ext_glWeightusvARB,
    ext_glWindowPos2d,
    ext_glWindowPos2dARB,
    ext_glWindowPos2dMESA,
    ext_glWindowPos2dv,
    ext_glWindowPos2dvARB,
    ext_glWindowPos2dvMESA,
    ext_glWindowPos2f,
    ext_glWindowPos2fARB,
    ext_glWindowPos2fMESA,
    ext_glWindowPos2fv,
    ext_glWindowPos2fvARB,
    ext_glWindowPos2fvMESA,
    ext_glWindowPos2i,
    ext_glWindowPos2iARB,
    ext_glWindowPos2iMESA,
    ext_glWindowPos2iv,
    ext_glWindowPos2ivARB,
    ext_glWindowPos2ivMESA,
    ext_glWindowPos2s,
    ext_glWindowPos2sARB,
    ext_glWindowPos2sMESA,
    ext_glWindowPos2sv,
    ext_glWindowPos2svARB,
    ext_glWindowPos2svMESA,
    ext_glWindowPos3d,
    ext_glWindowPos3dARB,
    ext_glWindowPos3dMESA,
    ext_glWindowPos3dv,
    ext_glWindowPos3dvARB,
    ext_glWindowPos3dvMESA,
    ext_glWindowPos3f,
    ext_glWindowPos3fARB,
    ext_glWindowPos3fMESA,
    ext_glWindowPos3fv,
    ext_glWindowPos3fvARB,
    ext_glWindowPos3fvMESA,
    ext_glWindowPos3i,
    ext_glWindowPos3iARB,
    ext_glWindowPos3iMESA,
    ext_glWindowPos3iv,
    ext_glWindowPos3ivARB,
    ext_glWindowPos3ivMESA,
    ext_glWindowPos3s,
    ext_glWindowPos3sARB,
    ext_glWindowPos3sMESA,
    ext_glWindowPos3sv,
    ext_glWindowPos3svARB,
    ext_glWindowPos3svMESA,
    ext_glWindowPos4dMESA,
    ext_glWindowPos4dvMESA,
    ext_glWindowPos4fMESA,
    ext_glWindowPos4fvMESA,
    ext_glWindowPos4iMESA,
    ext_glWindowPos4ivMESA,
    ext_glWindowPos4sMESA,
    ext_glWindowPos4svMESA,
    ext_glWindowRectanglesEXT,
    ext_glWriteMaskEXT,
    ext_wglAllocateMemoryNV,
    ext_wglBindTexImageARB,
    ext_wglCreateContextAttribsARB,
    ext_wglCreatePbufferARB,
    ext_wglDestroyPbufferARB,
    ext_wglFreeMemoryNV,
    ext_wglGetPbufferDCARB,
    ext_wglGetSwapIntervalEXT,
    ext_wglMakeContextCurrentARB,
    ext_wglQueryCurrentRendererIntegerWINE,
    ext_wglQueryCurrentRendererStringWINE,
    ext_wglQueryPbufferARB,
    ext_wglQueryRendererIntegerWINE,
    ext_wglQueryRendererStringWINE,
    ext_wglReleasePbufferDCARB,
    ext_wglReleaseTexImageARB,
    ext_wglSetPbufferAttribARB,
    ext_wglSetPixelFormatWINE,
    ext_wglSwapIntervalEXT,
};

C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == funcs_count);

#ifdef _WIN64

extern NTSTATUS wow64_thread_attach( void *args );
extern NTSTATUS wow64_process_detach( void *args );
extern NTSTATUS wow64_get_pixel_formats( void *args );

static NTSTATUS wow64_wgl_wglDeleteContext( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 oldContext;
        BOOL ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    params->ret = wrap_wglDeleteContext( teb, ULongToPtr(params->oldContext) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_wgl_wglGetPixelFormat( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 hdc;
        int ret;
    } *params = args;
    const struct opengl_funcs *funcs = get_dc_funcs( ULongToPtr(params->hdc) );
    if (!funcs || !funcs->p_wglGetPixelFormat) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglGetPixelFormat( ULongToPtr(params->hdc) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_wgl_wglSetPixelFormat( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 hdc;
        int ipfd;
        PTR32 ppfd;
        BOOL ret;
    } *params = args;
    const struct opengl_funcs *funcs = get_dc_funcs( ULongToPtr(params->hdc) );
    if (!funcs || !funcs->p_wglSetPixelFormat) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglSetPixelFormat( ULongToPtr(params->hdc), params->ipfd, ULongToPtr(params->ppfd) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_wgl_wglSwapBuffers( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 hdc;
        BOOL ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    params->ret = wrap_wglSwapBuffers( teb, ULongToPtr(params->hdc) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glAccum( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum op;
        GLfloat value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAccum) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAccum( params->op, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glAlphaFunc( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum func;
        GLfloat ref;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAlphaFunc) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAlphaFunc( params->func, params->ref );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glAreTexturesResident( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 textures;
        PTR32 residences;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAreTexturesResident) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glAreTexturesResident( params->n, ULongToPtr(params->textures), ULongToPtr(params->residences) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glArrayElement( void *args )
{
    struct
    {
        PTR32 teb;
        GLint i;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glArrayElement) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glArrayElement( params->i );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glBegin( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBegin) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBegin( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glBindTexture( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint texture;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindTexture) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindTexture( params->target, params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glBitmap( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei width;
        GLsizei height;
        GLfloat xorig;
        GLfloat yorig;
        GLfloat xmove;
        GLfloat ymove;
        PTR32 bitmap;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBitmap) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBitmap( params->width, params->height, params->xorig, params->yorig, params->xmove, params->ymove, ULongToPtr(params->bitmap) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glBlendFunc( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum sfactor;
        GLenum dfactor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendFunc) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFunc( params->sfactor, params->dfactor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glCallList( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint list;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCallList) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCallList( params->list );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glCallLists( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        GLenum type;
        PTR32 lists;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCallLists) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCallLists( params->n, params->type, ULongToPtr(params->lists) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glClear( void *args )
{
    struct
    {
        PTR32 teb;
        GLbitfield mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClear) return STATUS_NOT_IMPLEMENTED;
    wrap_glClear( teb, params->mask, funcs->p_glClear );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glClearAccum( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat red;
        GLfloat green;
        GLfloat blue;
        GLfloat alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearAccum) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearAccum( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glClearColor( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat red;
        GLfloat green;
        GLfloat blue;
        GLfloat alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearColor) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearColor( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glClearDepth( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble depth;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearDepth) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearDepth( params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glClearIndex( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat c;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearIndex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearIndex( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glClearStencil( void *args )
{
    struct
    {
        PTR32 teb;
        GLint s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearStencil) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearStencil( params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glClipPlane( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum plane;
        PTR32 equation;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClipPlane) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClipPlane( params->plane, ULongToPtr(params->equation) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor3b( void *args )
{
    struct
    {
        PTR32 teb;
        GLbyte red;
        GLbyte green;
        GLbyte blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3b) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3b( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor3bv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3bv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3bv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor3d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble red;
        GLdouble green;
        GLdouble blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3d( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor3dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3dv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor3f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat red;
        GLfloat green;
        GLfloat blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3f( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor3fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3fv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor3i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint red;
        GLint green;
        GLint blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3i( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor3iv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3iv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor3s( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort red;
        GLshort green;
        GLshort blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3s( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor3sv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3sv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor3ub( void *args )
{
    struct
    {
        PTR32 teb;
        GLubyte red;
        GLubyte green;
        GLubyte blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3ub) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3ub( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor3ubv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3ubv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3ubv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor3ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint red;
        GLuint green;
        GLuint blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3ui( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor3uiv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3uiv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor3us( void *args )
{
    struct
    {
        PTR32 teb;
        GLushort red;
        GLushort green;
        GLushort blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3us) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3us( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor3usv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3usv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3usv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor4b( void *args )
{
    struct
    {
        PTR32 teb;
        GLbyte red;
        GLbyte green;
        GLbyte blue;
        GLbyte alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4b) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4b( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor4bv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4bv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4bv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor4d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble red;
        GLdouble green;
        GLdouble blue;
        GLdouble alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4d( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor4dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4dv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor4f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat red;
        GLfloat green;
        GLfloat blue;
        GLfloat alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4f( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor4fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4fv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor4i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint red;
        GLint green;
        GLint blue;
        GLint alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4i( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor4iv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4iv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor4s( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort red;
        GLshort green;
        GLshort blue;
        GLshort alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4s( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor4sv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4sv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor4ub( void *args )
{
    struct
    {
        PTR32 teb;
        GLubyte red;
        GLubyte green;
        GLubyte blue;
        GLubyte alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4ub) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4ub( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor4ubv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4ubv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4ubv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor4ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint red;
        GLuint green;
        GLuint blue;
        GLuint alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4ui( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor4uiv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4uiv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor4us( void *args )
{
    struct
    {
        PTR32 teb;
        GLushort red;
        GLushort green;
        GLushort blue;
        GLushort alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4us) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4us( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColor4usv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4usv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4usv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColorMask( void *args )
{
    struct
    {
        PTR32 teb;
        GLboolean red;
        GLboolean green;
        GLboolean blue;
        GLboolean alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorMask) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorMask( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColorMaterial( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorMaterial) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorMaterial( params->face, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glColorPointer( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorPointer( params->size, params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glCopyPixels( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
        GLenum type;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyPixels) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyPixels( params->x, params->y, params->width, params->height, params->type );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glCopyTexImage1D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLint x;
        GLint y;
        GLsizei width;
        GLint border;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTexImage1D) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyTexImage1D( params->target, params->level, params->internalformat, params->x, params->y, params->width, params->border );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glCopyTexImage2D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
        GLint border;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTexImage2D) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyTexImage2D( params->target, params->level, params->internalformat, params->x, params->y, params->width, params->height, params->border );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glCopyTexSubImage1D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint x;
        GLint y;
        GLsizei width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTexSubImage1D) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyTexSubImage1D( params->target, params->level, params->xoffset, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glCopyTexSubImage2D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTexSubImage2D) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyTexSubImage2D( params->target, params->level, params->xoffset, params->yoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glCullFace( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCullFace) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCullFace( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glDeleteLists( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint list;
        GLsizei range;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteLists) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteLists( params->list, params->range );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glDeleteTextures( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 textures;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteTextures) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteTextures( params->n, ULongToPtr(params->textures) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glDepthFunc( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum func;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDepthFunc) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthFunc( params->func );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glDepthMask( void *args )
{
    struct
    {
        PTR32 teb;
        GLboolean flag;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDepthMask) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthMask( params->flag );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glDepthRange( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble n;
        GLdouble f;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDepthRange) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRange( params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glDisable( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum cap;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDisable) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisable( params->cap );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glDisableClientState( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum array;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDisableClientState) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableClientState( params->array );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glDrawArrays( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLint first;
        GLsizei count;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawArrays) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawArrays( params->mode, params->first, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glDrawBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum buf;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawBuffer) return STATUS_NOT_IMPLEMENTED;
    wrap_glDrawBuffer( teb, params->buf, funcs->p_glDrawBuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glDrawElements( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLsizei count;
        GLenum type;
        PTR32 indices;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawElements) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElements( params->mode, params->count, params->type, ULongToPtr(params->indices) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glDrawPixels( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawPixels) return STATUS_NOT_IMPLEMENTED;
    wrap_glDrawPixels( teb, params->width, params->height, params->format, params->type, ULongToPtr(params->pixels), funcs->p_glDrawPixels );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEdgeFlag( void *args )
{
    struct
    {
        PTR32 teb;
        GLboolean flag;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEdgeFlag) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEdgeFlag( params->flag );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEdgeFlagPointer( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEdgeFlagPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEdgeFlagPointer( params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEdgeFlagv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 flag;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEdgeFlagv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEdgeFlagv( ULongToPtr(params->flag) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEnable( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum cap;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEnable) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnable( params->cap );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEnableClientState( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum array;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEnableClientState) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableClientState( params->array );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEnd( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEnd) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnd();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEndList( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEndList) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndList();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEvalCoord1d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble u;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalCoord1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord1d( params->u );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEvalCoord1dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 u;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalCoord1dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord1dv( ULongToPtr(params->u) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEvalCoord1f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat u;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalCoord1f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord1f( params->u );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEvalCoord1fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 u;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalCoord1fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord1fv( ULongToPtr(params->u) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEvalCoord2d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble u;
        GLdouble v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalCoord2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord2d( params->u, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEvalCoord2dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 u;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalCoord2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord2dv( ULongToPtr(params->u) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEvalCoord2f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat u;
        GLfloat v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalCoord2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord2f( params->u, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEvalCoord2fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 u;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalCoord2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord2fv( ULongToPtr(params->u) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEvalMesh1( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLint i1;
        GLint i2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalMesh1) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalMesh1( params->mode, params->i1, params->i2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEvalMesh2( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLint i1;
        GLint i2;
        GLint j1;
        GLint j2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalMesh2) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalMesh2( params->mode, params->i1, params->i2, params->j1, params->j2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEvalPoint1( void *args )
{
    struct
    {
        PTR32 teb;
        GLint i;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalPoint1) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalPoint1( params->i );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glEvalPoint2( void *args )
{
    struct
    {
        PTR32 teb;
        GLint i;
        GLint j;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalPoint2) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalPoint2( params->i, params->j );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glFeedbackBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei size;
        GLenum type;
        PTR32 buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFeedbackBuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFeedbackBuffer( params->size, params->type, ULongToPtr(params->buffer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glFinish( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFinish) return STATUS_NOT_IMPLEMENTED;
    wrap_glFinish( teb, funcs->p_glFinish );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glFlush( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFlush) return STATUS_NOT_IMPLEMENTED;
    wrap_glFlush( teb, funcs->p_glFlush );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glFogf( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogf( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glFogfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogfv( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glFogi( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogi) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogi( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glFogiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogiv( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glFrontFace( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFrontFace) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFrontFace( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glFrustum( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble left;
        GLdouble right;
        GLdouble bottom;
        GLdouble top;
        GLdouble zNear;
        GLdouble zFar;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFrustum) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFrustum( params->left, params->right, params->bottom, params->top, params->zNear, params->zFar );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGenLists( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei range;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenLists) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGenLists( params->range );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGenTextures( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 textures;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenTextures) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenTextures( params->n, ULongToPtr(params->textures) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetBooleanv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetBooleanv) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetBooleanv( teb, params->pname, ULongToPtr(params->data), funcs->p_glGetBooleanv );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetClipPlane( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum plane;
        PTR32 equation;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetClipPlane) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetClipPlane( params->plane, ULongToPtr(params->equation) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetDoublev( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetDoublev) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetDoublev( teb, params->pname, ULongToPtr(params->data), funcs->p_glGetDoublev );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetError( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetError) return STATUS_NOT_IMPLEMENTED;
    params->ret = wrap_glGetError( teb, funcs->p_glGetError );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetFloatv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFloatv) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetFloatv( teb, params->pname, ULongToPtr(params->data), funcs->p_glGetFloatv );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetIntegerv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetIntegerv) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetIntegerv( teb, params->pname, ULongToPtr(params->data), funcs->p_glGetIntegerv );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetLightfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetLightfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetLightfv( params->light, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetLightiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetLightiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetLightiv( params->light, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetMapdv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum query;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMapdv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapdv( params->target, params->query, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetMapfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum query;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMapfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapfv( params->target, params->query, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetMapiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum query;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMapiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapiv( params->target, params->query, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetMaterialfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMaterialfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMaterialfv( params->face, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetMaterialiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMaterialiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMaterialiv( params->face, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetPixelMapfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum map;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPixelMapfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPixelMapfv( params->map, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetPixelMapuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum map;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPixelMapuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPixelMapuiv( params->map, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetPixelMapusv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum map;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPixelMapusv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPixelMapusv( params->map, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetPointerv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    void *params_arg;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPointerv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPointerv( params->pname, &params_arg );
    *(PTR32 *)UlongToPtr(params->params) = PtrToUlong( params_arg );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetPolygonStipple( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPolygonStipple) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPolygonStipple( ULongToPtr(params->mask) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetString( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum name;
        PTR32 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const GLubyte *ret;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetString) return STATUS_NOT_IMPLEMENTED;
    ret = wrap_glGetString( teb, params->name, funcs->p_glGetString );
    return return_wow64_string( ret, &params->ret );
}

static NTSTATUS wow64_gl_glGetTexEnvfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexEnvfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexEnvfv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetTexEnviv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexEnviv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexEnviv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetTexGendv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum coord;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexGendv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexGendv( params->coord, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetTexGenfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum coord;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexGenfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexGenfv( params->coord, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetTexGeniv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum coord;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexGeniv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexGeniv( params->coord, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetTexImage( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexImage( params->target, params->level, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetTexLevelParameterfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexLevelParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexLevelParameterfv( params->target, params->level, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetTexLevelParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexLevelParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexLevelParameteriv( params->target, params->level, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetTexParameterfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameterfv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glGetTexParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameteriv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glHint( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glHint) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glHint( params->target, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glIndexMask( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexMask) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexMask( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glIndexPointer( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexPointer( params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glIndexd( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble c;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexd) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexd( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glIndexdv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 c;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexdv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexdv( ULongToPtr(params->c) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glIndexf( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat c;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexf( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glIndexfv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 c;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexfv( ULongToPtr(params->c) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glIndexi( void *args )
{
    struct
    {
        PTR32 teb;
        GLint c;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexi) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexi( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glIndexiv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 c;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexiv( ULongToPtr(params->c) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glIndexs( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort c;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexs) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexs( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glIndexsv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 c;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexsv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexsv( ULongToPtr(params->c) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glIndexub( void *args )
{
    struct
    {
        PTR32 teb;
        GLubyte c;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexub) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexub( params->c );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glIndexubv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 c;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexubv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexubv( ULongToPtr(params->c) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glInitNames( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glInitNames) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInitNames();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glInterleavedArrays( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum format;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glInterleavedArrays) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInterleavedArrays( params->format, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glIsEnabled( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum cap;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsEnabled) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsEnabled( params->cap );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glIsList( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint list;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsList) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsList( params->list );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glIsTexture( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsTexture) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsTexture( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glLightModelf( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLightModelf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightModelf( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glLightModelfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLightModelfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightModelfv( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glLightModeli( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLightModeli) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightModeli( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glLightModeliv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLightModeliv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightModeliv( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glLightf( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLightf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightf( params->light, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glLightfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLightfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightfv( params->light, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glLighti( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLighti) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLighti( params->light, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glLightiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLightiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightiv( params->light, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glLineStipple( void *args )
{
    struct
    {
        PTR32 teb;
        GLint factor;
        GLushort pattern;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLineStipple) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLineStipple( params->factor, params->pattern );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glLineWidth( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLineWidth) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLineWidth( params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glListBase( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint base;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glListBase) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glListBase( params->base );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glLoadIdentity( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLoadIdentity) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadIdentity();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glLoadMatrixd( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLoadMatrixd) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadMatrixd( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glLoadMatrixf( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLoadMatrixf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadMatrixf( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glLoadName( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLoadName) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadName( params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glLogicOp( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum opcode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLogicOp) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLogicOp( params->opcode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glMap1d( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLdouble u1;
        GLdouble u2;
        GLint stride;
        GLint order;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMap1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMap1d( params->target, params->u1, params->u2, params->stride, params->order, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glMap1f( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfloat u1;
        GLfloat u2;
        GLint stride;
        GLint order;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMap1f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMap1f( params->target, params->u1, params->u2, params->stride, params->order, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glMap2d( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLdouble u1;
        GLdouble u2;
        GLint ustride;
        GLint uorder;
        GLdouble v1;
        GLdouble v2;
        GLint vstride;
        GLint vorder;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMap2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMap2d( params->target, params->u1, params->u2, params->ustride, params->uorder, params->v1, params->v2, params->vstride, params->vorder, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glMap2f( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfloat u1;
        GLfloat u2;
        GLint ustride;
        GLint uorder;
        GLfloat v1;
        GLfloat v2;
        GLint vstride;
        GLint vorder;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMap2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMap2f( params->target, params->u1, params->u2, params->ustride, params->uorder, params->v1, params->v2, params->vstride, params->vorder, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glMapGrid1d( void *args )
{
    struct
    {
        PTR32 teb;
        GLint un;
        GLdouble u1;
        GLdouble u2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapGrid1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapGrid1d( params->un, params->u1, params->u2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glMapGrid1f( void *args )
{
    struct
    {
        PTR32 teb;
        GLint un;
        GLfloat u1;
        GLfloat u2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapGrid1f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapGrid1f( params->un, params->u1, params->u2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glMapGrid2d( void *args )
{
    struct
    {
        PTR32 teb;
        GLint un;
        GLdouble u1;
        GLdouble u2;
        GLint vn;
        GLdouble v1;
        GLdouble v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapGrid2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapGrid2d( params->un, params->u1, params->u2, params->vn, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glMapGrid2f( void *args )
{
    struct
    {
        PTR32 teb;
        GLint un;
        GLfloat u1;
        GLfloat u2;
        GLint vn;
        GLfloat v1;
        GLfloat v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapGrid2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapGrid2f( params->un, params->u1, params->u2, params->vn, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glMaterialf( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMaterialf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaterialf( params->face, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glMaterialfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMaterialfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaterialfv( params->face, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glMateriali( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMateriali) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMateriali( params->face, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glMaterialiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMaterialiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaterialiv( params->face, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glMatrixMode( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixMode) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixMode( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glMultMatrixd( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultMatrixd) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultMatrixd( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glMultMatrixf( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultMatrixf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultMatrixf( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glNewList( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint list;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNewList) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNewList( params->list, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glNormal3b( void *args )
{
    struct
    {
        PTR32 teb;
        GLbyte nx;
        GLbyte ny;
        GLbyte nz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3b) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3b( params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glNormal3bv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3bv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3bv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glNormal3d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble nx;
        GLdouble ny;
        GLdouble nz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3d( params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glNormal3dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3dv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glNormal3f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat nx;
        GLfloat ny;
        GLfloat nz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3f( params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glNormal3fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3fv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glNormal3i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint nx;
        GLint ny;
        GLint nz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3i( params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glNormal3iv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3iv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glNormal3s( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort nx;
        GLshort ny;
        GLshort nz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3s( params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glNormal3sv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3sv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glNormalPointer( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormalPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalPointer( params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glOrtho( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble left;
        GLdouble right;
        GLdouble bottom;
        GLdouble top;
        GLdouble zNear;
        GLdouble zFar;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glOrtho) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glOrtho( params->left, params->right, params->bottom, params->top, params->zNear, params->zFar );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPassThrough( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat token;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPassThrough) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPassThrough( params->token );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPixelMapfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum map;
        GLsizei mapsize;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelMapfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelMapfv( params->map, params->mapsize, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPixelMapuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum map;
        GLsizei mapsize;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelMapuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelMapuiv( params->map, params->mapsize, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPixelMapusv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum map;
        GLsizei mapsize;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelMapusv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelMapusv( params->map, params->mapsize, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPixelStoref( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelStoref) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelStoref( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPixelStorei( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelStorei) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelStorei( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPixelTransferf( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelTransferf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTransferf( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPixelTransferi( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelTransferi) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTransferi( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPixelZoom( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat xfactor;
        GLfloat yfactor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelZoom) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelZoom( params->xfactor, params->yfactor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPointSize( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat size;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointSize) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointSize( params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPolygonMode( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPolygonMode) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPolygonMode( params->face, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPolygonOffset( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat factor;
        GLfloat units;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPolygonOffset) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPolygonOffset( params->factor, params->units );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPolygonStipple( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPolygonStipple) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPolygonStipple( ULongToPtr(params->mask) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPopAttrib( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPopAttrib) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPopAttrib();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPopClientAttrib( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPopClientAttrib) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPopClientAttrib();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPopMatrix( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPopMatrix) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPopMatrix();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPopName( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPopName) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPopName();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPrioritizeTextures( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 textures;
        PTR32 priorities;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPrioritizeTextures) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPrioritizeTextures( params->n, ULongToPtr(params->textures), ULongToPtr(params->priorities) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPushAttrib( void *args )
{
    struct
    {
        PTR32 teb;
        GLbitfield mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPushAttrib) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPushAttrib( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPushClientAttrib( void *args )
{
    struct
    {
        PTR32 teb;
        GLbitfield mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPushClientAttrib) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPushClientAttrib( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPushMatrix( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPushMatrix) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPushMatrix();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glPushName( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPushName) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPushName( params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos2d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble x;
        GLdouble y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2d( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos2dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2dv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos2f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat x;
        GLfloat y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2f( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos2fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2fv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos2i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos2i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2i( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos2iv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos2iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2iv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos2s( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort x;
        GLshort y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos2s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2s( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos2sv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos2sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2sv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos3d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3d( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos3dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3dv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos3f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3f( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos3fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3fv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos3i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
        GLint z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3i( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos3iv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3iv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos3s( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort x;
        GLshort y;
        GLshort z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3s( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos3sv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3sv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos4d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble x;
        GLdouble y;
        GLdouble z;
        GLdouble w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4d( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos4dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4dv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos4f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat x;
        GLfloat y;
        GLfloat z;
        GLfloat w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos4f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4f( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos4fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4fv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos4i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
        GLint z;
        GLint w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos4i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4i( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos4iv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4iv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos4s( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort x;
        GLshort y;
        GLshort z;
        GLshort w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos4s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4s( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRasterPos4sv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos4sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4sv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glReadBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum src;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReadBuffer) return STATUS_NOT_IMPLEMENTED;
    wrap_glReadBuffer( teb, params->src, funcs->p_glReadBuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glReadPixels( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReadPixels) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    wrap_glReadPixels( teb, params->x, params->y, params->width, params->height, params->format, params->type, ULongToPtr(params->pixels), funcs->p_glReadPixels );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRectd( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble x1;
        GLdouble y1;
        GLdouble x2;
        GLdouble y2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRectd) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRectd( params->x1, params->y1, params->x2, params->y2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRectdv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v1;
        PTR32 v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRectdv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRectdv( ULongToPtr(params->v1), ULongToPtr(params->v2) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRectf( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat x1;
        GLfloat y1;
        GLfloat x2;
        GLfloat y2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRectf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRectf( params->x1, params->y1, params->x2, params->y2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRectfv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v1;
        PTR32 v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRectfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRectfv( ULongToPtr(params->v1), ULongToPtr(params->v2) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRecti( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x1;
        GLint y1;
        GLint x2;
        GLint y2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRecti) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRecti( params->x1, params->y1, params->x2, params->y2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRectiv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v1;
        PTR32 v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRectiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRectiv( ULongToPtr(params->v1), ULongToPtr(params->v2) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRects( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort x1;
        GLshort y1;
        GLshort x2;
        GLshort y2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRects) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRects( params->x1, params->y1, params->x2, params->y2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRectsv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v1;
        PTR32 v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRectsv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRectsv( ULongToPtr(params->v1), ULongToPtr(params->v2) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRenderMode( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRenderMode) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glRenderMode( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRotated( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble angle;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRotated) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRotated( params->angle, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glRotatef( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat angle;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRotatef) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRotatef( params->angle, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glScaled( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glScaled) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScaled( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glScalef( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glScalef) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScalef( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glScissor( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glScissor) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScissor( params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glSelectBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei size;
        PTR32 buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSelectBuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSelectBuffer( params->size, ULongToPtr(params->buffer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glShadeModel( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glShadeModel) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShadeModel( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glStencilFunc( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum func;
        GLint ref;
        GLuint mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilFunc) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilFunc( params->func, params->ref, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glStencilMask( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilMask) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilMask( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glStencilOp( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum fail;
        GLenum zfail;
        GLenum zpass;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilOp) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilOp( params->fail, params->zfail, params->zpass );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord1d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1d( params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord1dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord1dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1dv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord1f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord1f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1f( params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord1fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord1fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1fv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord1i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord1i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1i( params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord1iv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord1iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1iv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord1s( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord1s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1s( params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord1sv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord1sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1sv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord2d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble s;
        GLdouble t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2d( params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord2dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2dv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord2f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat s;
        GLfloat t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2f( params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord2fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord2i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint s;
        GLint t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2i( params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord2iv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2iv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord2s( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort s;
        GLshort t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2s( params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord2sv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2sv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord3d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble s;
        GLdouble t;
        GLdouble r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3d( params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord3dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3dv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord3f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat s;
        GLfloat t;
        GLfloat r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3f( params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord3fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3fv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord3i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint s;
        GLint t;
        GLint r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3i( params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord3iv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3iv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord3s( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort s;
        GLshort t;
        GLshort r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3s( params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord3sv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3sv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord4d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble s;
        GLdouble t;
        GLdouble r;
        GLdouble q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4d( params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord4dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4dv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord4f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat s;
        GLfloat t;
        GLfloat r;
        GLfloat q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4f( params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord4fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4fv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord4i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint s;
        GLint t;
        GLint r;
        GLint q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4i( params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord4iv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4iv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord4s( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort s;
        GLshort t;
        GLshort r;
        GLshort q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4s( params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoord4sv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4sv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexCoordPointer( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoordPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordPointer( params->size, params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexEnvf( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexEnvf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexEnvf( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexEnvfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexEnvfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexEnvfv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexEnvi( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexEnvi) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexEnvi( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexEnviv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexEnviv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexEnviv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexGend( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum coord;
        GLenum pname;
        GLdouble param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexGend) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexGend( params->coord, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexGendv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum coord;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexGendv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexGendv( params->coord, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexGenf( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum coord;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexGenf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexGenf( params->coord, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexGenfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum coord;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexGenfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexGenfv( params->coord, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexGeni( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum coord;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexGeni) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexGeni( params->coord, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexGeniv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum coord;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexGeniv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexGeniv( params->coord, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexImage1D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint internalformat;
        GLsizei width;
        GLint border;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexImage1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage1D( params->target, params->level, params->internalformat, params->width, params->border, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexImage2D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint internalformat;
        GLsizei width;
        GLsizei height;
        GLint border;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexImage2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage2D( params->target, params->level, params->internalformat, params->width, params->height, params->border, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexParameterf( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexParameterf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterf( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexParameterfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterfv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexParameteri( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexParameteri) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameteri( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameteriv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexSubImage1D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLsizei width;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexSubImage1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexSubImage1D( params->target, params->level, params->xoffset, params->width, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTexSubImage2D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexSubImage2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexSubImage2D( params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTranslated( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTranslated) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTranslated( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glTranslatef( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTranslatef) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTranslatef( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex2d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble x;
        GLdouble y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2d( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex2dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2dv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex2f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat x;
        GLfloat y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2f( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex2fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2fv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex2i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex2i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2i( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex2iv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex2iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2iv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex2s( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort x;
        GLshort y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex2s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2s( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex2sv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex2sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2sv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex3d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3d( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex3dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3dv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex3f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3f( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex3fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3fv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex3i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
        GLint z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3i( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex3iv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3iv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex3s( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort x;
        GLshort y;
        GLshort z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3s( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex3sv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3sv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex4d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble x;
        GLdouble y;
        GLdouble z;
        GLdouble w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4d( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex4dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4dv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex4f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat x;
        GLfloat y;
        GLfloat z;
        GLfloat w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex4f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4f( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex4fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4fv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex4i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
        GLint z;
        GLint w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex4i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4i( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex4iv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4iv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex4s( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort x;
        GLshort y;
        GLshort z;
        GLshort w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex4s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4s( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertex4sv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex4sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4sv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glVertexPointer( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexPointer( params->size, params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_gl_glViewport( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glViewport) return STATUS_NOT_IMPLEMENTED;
    wrap_glViewport( teb, params->x, params->y, params->width, params->height, funcs->p_glViewport );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glAccumxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum op;
        GLfixed value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAccumxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAccumxOES( params->op, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glAcquireKeyedMutexWin32EXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint memory;
        GLuint64 key;
        GLuint timeout;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAcquireKeyedMutexWin32EXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glAcquireKeyedMutexWin32EXT( params->memory, params->key, params->timeout );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glActiveProgramEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glActiveProgramEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glActiveProgramEXT( params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glActiveShaderProgram( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint pipeline;
        GLuint program;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glActiveShaderProgram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glActiveShaderProgram( params->pipeline, params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glActiveStencilFaceEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glActiveStencilFaceEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glActiveStencilFaceEXT( params->face );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glActiveTexture( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glActiveTexture) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glActiveTexture( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glActiveTextureARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glActiveTextureARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glActiveTextureARB( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glActiveVaryingNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glActiveVaryingNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glActiveVaryingNV( params->program, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glAlphaFragmentOp1ATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum op;
        GLuint dst;
        GLuint dstMod;
        GLuint arg1;
        GLuint arg1Rep;
        GLuint arg1Mod;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAlphaFragmentOp1ATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAlphaFragmentOp1ATI( params->op, params->dst, params->dstMod, params->arg1, params->arg1Rep, params->arg1Mod );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glAlphaFragmentOp2ATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum op;
        GLuint dst;
        GLuint dstMod;
        GLuint arg1;
        GLuint arg1Rep;
        GLuint arg1Mod;
        GLuint arg2;
        GLuint arg2Rep;
        GLuint arg2Mod;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAlphaFragmentOp2ATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAlphaFragmentOp2ATI( params->op, params->dst, params->dstMod, params->arg1, params->arg1Rep, params->arg1Mod, params->arg2, params->arg2Rep, params->arg2Mod );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glAlphaFragmentOp3ATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum op;
        GLuint dst;
        GLuint dstMod;
        GLuint arg1;
        GLuint arg1Rep;
        GLuint arg1Mod;
        GLuint arg2;
        GLuint arg2Rep;
        GLuint arg2Mod;
        GLuint arg3;
        GLuint arg3Rep;
        GLuint arg3Mod;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAlphaFragmentOp3ATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAlphaFragmentOp3ATI( params->op, params->dst, params->dstMod, params->arg1, params->arg1Rep, params->arg1Mod, params->arg2, params->arg2Rep, params->arg2Mod, params->arg3, params->arg3Rep, params->arg3Mod );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glAlphaFuncx( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum func;
        GLfixed ref;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAlphaFuncx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAlphaFuncx( params->func, params->ref );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glAlphaFuncxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum func;
        GLfixed ref;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAlphaFuncxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAlphaFuncxOES( params->func, params->ref );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glAlphaToCoverageDitherControlNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAlphaToCoverageDitherControlNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAlphaToCoverageDitherControlNV( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glApplyFramebufferAttachmentCMAAINTEL( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glApplyFramebufferAttachmentCMAAINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glApplyFramebufferAttachmentCMAAINTEL();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glApplyTextureEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glApplyTextureEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glApplyTextureEXT( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glAreProgramsResidentNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 programs;
        PTR32 residences;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAreProgramsResidentNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glAreProgramsResidentNV( params->n, ULongToPtr(params->programs), ULongToPtr(params->residences) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glAreTexturesResidentEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 textures;
        PTR32 residences;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAreTexturesResidentEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glAreTexturesResidentEXT( params->n, ULongToPtr(params->textures), ULongToPtr(params->residences) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glArrayElementEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint i;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glArrayElementEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glArrayElementEXT( params->i );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glArrayObjectATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum array;
        GLint size;
        GLenum type;
        GLsizei stride;
        GLuint buffer;
        GLuint offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glArrayObjectATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glArrayObjectATI( params->array, params->size, params->type, params->stride, params->buffer, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glAsyncCopyBufferSubDataNVX( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei waitSemaphoreCount;
        PTR32 waitSemaphoreArray;
        PTR32 fenceValueArray;
        GLuint readGpu;
        GLbitfield writeGpuMask;
        GLuint readBuffer;
        GLuint writeBuffer;
        PTR32 readOffset;
        PTR32 writeOffset;
        PTR32 size;
        GLsizei signalSemaphoreCount;
        PTR32 signalSemaphoreArray;
        PTR32 signalValueArray;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAsyncCopyBufferSubDataNVX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glAsyncCopyBufferSubDataNVX( params->waitSemaphoreCount, ULongToPtr(params->waitSemaphoreArray), ULongToPtr(params->fenceValueArray), params->readGpu, params->writeGpuMask, params->readBuffer, params->writeBuffer, (GLintptr)ULongToPtr(params->readOffset), (GLintptr)ULongToPtr(params->writeOffset), (GLsizeiptr)ULongToPtr(params->size), params->signalSemaphoreCount, ULongToPtr(params->signalSemaphoreArray), ULongToPtr(params->signalValueArray) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glAsyncCopyImageSubDataNVX( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei waitSemaphoreCount;
        PTR32 waitSemaphoreArray;
        PTR32 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;
        PTR32 signalSemaphoreArray;
        PTR32 signalValueArray;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAsyncCopyImageSubDataNVX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glAsyncCopyImageSubDataNVX( params->waitSemaphoreCount, ULongToPtr(params->waitSemaphoreArray), ULongToPtr(params->waitValueArray), params->srcGpu, params->dstGpuMask, params->srcName, params->srcTarget, params->srcLevel, params->srcX, params->srcY, params->srcZ, params->dstName, params->dstTarget, params->dstLevel, params->dstX, params->dstY, params->dstZ, params->srcWidth, params->srcHeight, params->srcDepth, params->signalSemaphoreCount, ULongToPtr(params->signalSemaphoreArray), ULongToPtr(params->signalValueArray) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glAsyncMarkerSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint marker;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAsyncMarkerSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAsyncMarkerSGIX( params->marker );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glAttachObjectARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB containerObj;
        GLhandleARB obj;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAttachObjectARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAttachObjectARB( params->containerObj, params->obj );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glAttachShader( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint shader;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glAttachShader) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glAttachShader( params->program, params->shader );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBeginConditionalRender( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBeginConditionalRender) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginConditionalRender( params->id, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBeginConditionalRenderNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBeginConditionalRenderNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginConditionalRenderNV( params->id, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBeginConditionalRenderNVX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBeginConditionalRenderNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginConditionalRenderNVX( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBeginFragmentShaderATI( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBeginFragmentShaderATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginFragmentShaderATI();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBeginOcclusionQueryNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBeginOcclusionQueryNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginOcclusionQueryNV( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBeginPerfMonitorAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint monitor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBeginPerfMonitorAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginPerfMonitorAMD( params->monitor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBeginPerfQueryINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint queryHandle;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBeginPerfQueryINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginPerfQueryINTEL( params->queryHandle );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBeginQuery( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint id;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBeginQuery) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginQuery( params->target, params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBeginQueryARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint id;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBeginQueryARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginQueryARB( params->target, params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBeginQueryIndexed( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLuint id;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBeginQueryIndexed) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginQueryIndexed( params->target, params->index, params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBeginTransformFeedback( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum primitiveMode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBeginTransformFeedback) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginTransformFeedback( params->primitiveMode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBeginTransformFeedbackEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum primitiveMode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBeginTransformFeedbackEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginTransformFeedbackEXT( params->primitiveMode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBeginTransformFeedbackNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum primitiveMode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBeginTransformFeedbackNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginTransformFeedbackNV( params->primitiveMode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBeginVertexShaderEXT( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBeginVertexShaderEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginVertexShaderEXT();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBeginVideoCaptureNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_capture_slot;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBeginVideoCaptureNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBeginVideoCaptureNV( params->video_capture_slot );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindAttribLocation( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint index;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindAttribLocation) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindAttribLocation( params->program, params->index, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindAttribLocationARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB programObj;
        GLuint index;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindAttribLocationARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindAttribLocationARB( params->programObj, params->index, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindBuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBuffer( params->target, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindBufferARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindBufferARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferARB( params->target, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindBufferBase( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindBufferBase) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferBase( params->target, params->index, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindBufferBaseEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindBufferBaseEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferBaseEXT( params->target, params->index, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindBufferBaseNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindBufferBaseNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferBaseNV( params->target, params->index, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindBufferOffsetEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLuint buffer;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindBufferOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferOffsetEXT( params->target, params->index, params->buffer, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindBufferOffsetNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLuint buffer;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindBufferOffsetNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferOffsetNV( params->target, params->index, params->buffer, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindBufferRange( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLuint buffer;
        PTR32 offset;
        PTR32 size;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindBufferRange) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferRange( params->target, params->index, params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindBufferRangeEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLuint buffer;
        PTR32 offset;
        PTR32 size;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindBufferRangeEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferRangeEXT( params->target, params->index, params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindBufferRangeNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLuint buffer;
        PTR32 offset;
        PTR32 size;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindBufferRangeNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBufferRangeNV( params->target, params->index, params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindBuffersBase( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint first;
        GLsizei count;
        PTR32 buffers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindBuffersBase) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindBuffersBase( params->target, params->first, params->count, ULongToPtr(params->buffers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindBuffersRange( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint first;
        GLsizei count;
        PTR32 buffers;
        PTR32 offsets;
        PTR32 sizes;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLintptr *offsets;
    GLsizeiptr *sizes;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindBuffersRange) return STATUS_NOT_IMPLEMENTED;
    offsets = copy_wow64_ptr32s( params->offsets, params->count );
    sizes = copy_wow64_ptr32s( params->sizes, params->count );
    funcs->p_glBindBuffersRange( params->target, params->first, params->count, ULongToPtr(params->buffers), offsets, sizes );
    free( offsets );
    free( sizes );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindFragDataLocation( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint color;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindFragDataLocation) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindFragDataLocation( params->program, params->color, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindFragDataLocationEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint color;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindFragDataLocationEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindFragDataLocationEXT( params->program, params->color, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindFragDataLocationIndexed( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint colorNumber;
        GLuint index;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindFragDataLocationIndexed) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindFragDataLocationIndexed( params->program, params->colorNumber, params->index, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindFragmentShaderATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindFragmentShaderATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindFragmentShaderATI( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindFramebuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint framebuffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindFramebuffer) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, params->target );
    funcs->p_glBindFramebuffer( params->target, framebuffer );
    set_current_fbo( teb, params->target, params->framebuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindFramebufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint framebuffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindFramebufferEXT) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, params->target );
    funcs->p_glBindFramebufferEXT( params->target, framebuffer );
    set_current_fbo( teb, params->target, params->framebuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindImageTexture( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint unit;
        GLuint texture;
        GLint level;
        GLboolean layered;
        GLint layer;
        GLenum access;
        GLenum format;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindImageTexture) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindImageTexture( params->unit, params->texture, params->level, params->layered, params->layer, params->access, params->format );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindImageTextureEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint texture;
        GLint level;
        GLboolean layered;
        GLint layer;
        GLenum access;
        GLint format;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindImageTextureEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindImageTextureEXT( params->index, params->texture, params->level, params->layered, params->layer, params->access, params->format );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindImageTextures( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint first;
        GLsizei count;
        PTR32 textures;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindImageTextures) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindImageTextures( params->first, params->count, ULongToPtr(params->textures) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindLightParameterEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum value;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindLightParameterEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glBindLightParameterEXT( params->light, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindMaterialParameterEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum value;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindMaterialParameterEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glBindMaterialParameterEXT( params->face, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindMultiTextureEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLuint texture;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindMultiTextureEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindMultiTextureEXT( params->texunit, params->target, params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindParameterEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum value;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindParameterEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glBindParameterEXT( params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindProgramARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint program;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindProgramARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindProgramARB( params->target, params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindProgramNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint id;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindProgramNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindProgramNV( params->target, params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindProgramPipeline( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint pipeline;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindProgramPipeline) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindProgramPipeline( params->pipeline );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindRenderbuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint renderbuffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindRenderbuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindRenderbuffer( params->target, params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindRenderbufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint renderbuffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindRenderbufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindRenderbufferEXT( params->target, params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindSampler( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint unit;
        GLuint sampler;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindSampler) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindSampler( params->unit, params->sampler );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindSamplers( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint first;
        GLsizei count;
        PTR32 samplers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindSamplers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindSamplers( params->first, params->count, ULongToPtr(params->samplers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindShadingRateImageNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindShadingRateImageNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindShadingRateImageNV( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindTexGenParameterEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum unit;
        GLenum coord;
        GLenum value;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindTexGenParameterEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glBindTexGenParameterEXT( params->unit, params->coord, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindTextureEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint texture;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindTextureEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindTextureEXT( params->target, params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindTextureUnit( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint unit;
        GLuint texture;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindTextureUnit) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindTextureUnit( params->unit, params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindTextureUnitParameterEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum unit;
        GLenum value;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindTextureUnitParameterEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glBindTextureUnitParameterEXT( params->unit, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindTextures( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint first;
        GLsizei count;
        PTR32 textures;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindTextures) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindTextures( params->first, params->count, ULongToPtr(params->textures) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindTransformFeedback( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint id;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindTransformFeedback) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindTransformFeedback( params->target, params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindTransformFeedbackNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint id;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindTransformFeedbackNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindTransformFeedbackNV( params->target, params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindVertexArray( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint array;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindVertexArray) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindVertexArray( params->array );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindVertexArrayAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint array;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindVertexArrayAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindVertexArrayAPPLE( params->array );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindVertexBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint bindingindex;
        GLuint buffer;
        PTR32 offset;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindVertexBuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindVertexBuffer( params->bindingindex, params->buffer, (GLintptr)ULongToPtr(params->offset), params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindVertexBuffers( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint first;
        GLsizei count;
        PTR32 buffers;
        PTR32 offsets;
        PTR32 strides;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLintptr *offsets;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindVertexBuffers) return STATUS_NOT_IMPLEMENTED;
    offsets = copy_wow64_ptr32s( params->offsets, params->count );
    funcs->p_glBindVertexBuffers( params->first, params->count, ULongToPtr(params->buffers), offsets, ULongToPtr(params->strides) );
    free( offsets );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindVertexShaderEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindVertexShaderEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindVertexShaderEXT( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindVideoCaptureStreamBufferNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_capture_slot;
        GLuint stream;
        GLenum frame_region;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindVideoCaptureStreamBufferNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindVideoCaptureStreamBufferNV( params->video_capture_slot, params->stream, params->frame_region, (GLintptrARB)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBindVideoCaptureStreamTextureNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_capture_slot;
        GLuint stream;
        GLenum frame_region;
        GLenum target;
        GLuint texture;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBindVideoCaptureStreamTextureNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBindVideoCaptureStreamTextureNV( params->video_capture_slot, params->stream, params->frame_region, params->target, params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBinormal3bEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLbyte bx;
        GLbyte by;
        GLbyte bz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBinormal3bEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3bEXT( params->bx, params->by, params->bz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBinormal3bvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBinormal3bvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3bvEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBinormal3dEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble bx;
        GLdouble by;
        GLdouble bz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBinormal3dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3dEXT( params->bx, params->by, params->bz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBinormal3dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBinormal3dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3dvEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBinormal3fEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat bx;
        GLfloat by;
        GLfloat bz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBinormal3fEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3fEXT( params->bx, params->by, params->bz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBinormal3fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBinormal3fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3fvEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBinormal3iEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint bx;
        GLint by;
        GLint bz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBinormal3iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3iEXT( params->bx, params->by, params->bz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBinormal3ivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBinormal3ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3ivEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBinormal3sEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort bx;
        GLshort by;
        GLshort bz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBinormal3sEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3sEXT( params->bx, params->by, params->bz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBinormal3svEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBinormal3svEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormal3svEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBinormalPointerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBinormalPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBinormalPointerEXT( params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBitmapxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei width;
        GLsizei height;
        GLfixed xorig;
        GLfixed yorig;
        GLfixed xmove;
        GLfixed ymove;
        PTR32 bitmap;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBitmapxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBitmapxOES( params->width, params->height, params->xorig, params->yorig, params->xmove, params->ymove, ULongToPtr(params->bitmap) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendBarrier( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendBarrier) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendBarrier();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendBarrierKHR( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendBarrierKHR) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendBarrierKHR();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendBarrierNV( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendBarrierNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendBarrierNV();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendColor( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat red;
        GLfloat green;
        GLfloat blue;
        GLfloat alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendColor) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendColor( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendColorEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat red;
        GLfloat green;
        GLfloat blue;
        GLfloat alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendColorEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendColorEXT( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendColorxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed red;
        GLfixed green;
        GLfixed blue;
        GLfixed alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendColorxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendColorxOES( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendEquation( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendEquation) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquation( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendEquationEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendEquationEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationEXT( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendEquationIndexedAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buf;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendEquationIndexedAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationIndexedAMD( params->buf, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendEquationSeparate( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum modeRGB;
        GLenum modeAlpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendEquationSeparate) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationSeparate( params->modeRGB, params->modeAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendEquationSeparateEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum modeRGB;
        GLenum modeAlpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendEquationSeparateEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationSeparateEXT( params->modeRGB, params->modeAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendEquationSeparateIndexedAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buf;
        GLenum modeRGB;
        GLenum modeAlpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendEquationSeparateIndexedAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationSeparateIndexedAMD( params->buf, params->modeRGB, params->modeAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendEquationSeparatei( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buf;
        GLenum modeRGB;
        GLenum modeAlpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendEquationSeparatei) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationSeparatei( params->buf, params->modeRGB, params->modeAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendEquationSeparateiARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buf;
        GLenum modeRGB;
        GLenum modeAlpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendEquationSeparateiARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationSeparateiARB( params->buf, params->modeRGB, params->modeAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendEquationi( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buf;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendEquationi) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationi( params->buf, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendEquationiARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buf;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendEquationiARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendEquationiARB( params->buf, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendFuncIndexedAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buf;
        GLenum src;
        GLenum dst;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendFuncIndexedAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFuncIndexedAMD( params->buf, params->src, params->dst );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendFuncSeparate( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum sfactorRGB;
        GLenum dfactorRGB;
        GLenum sfactorAlpha;
        GLenum dfactorAlpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendFuncSeparate) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFuncSeparate( params->sfactorRGB, params->dfactorRGB, params->sfactorAlpha, params->dfactorAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendFuncSeparateEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum sfactorRGB;
        GLenum dfactorRGB;
        GLenum sfactorAlpha;
        GLenum dfactorAlpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendFuncSeparateEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFuncSeparateEXT( params->sfactorRGB, params->dfactorRGB, params->sfactorAlpha, params->dfactorAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendFuncSeparateINGR( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum sfactorRGB;
        GLenum dfactorRGB;
        GLenum sfactorAlpha;
        GLenum dfactorAlpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendFuncSeparateINGR) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFuncSeparateINGR( params->sfactorRGB, params->dfactorRGB, params->sfactorAlpha, params->dfactorAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendFuncSeparateIndexedAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buf;
        GLenum srcRGB;
        GLenum dstRGB;
        GLenum srcAlpha;
        GLenum dstAlpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendFuncSeparateIndexedAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFuncSeparateIndexedAMD( params->buf, params->srcRGB, params->dstRGB, params->srcAlpha, params->dstAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendFuncSeparatei( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buf;
        GLenum srcRGB;
        GLenum dstRGB;
        GLenum srcAlpha;
        GLenum dstAlpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendFuncSeparatei) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFuncSeparatei( params->buf, params->srcRGB, params->dstRGB, params->srcAlpha, params->dstAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendFuncSeparateiARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buf;
        GLenum srcRGB;
        GLenum dstRGB;
        GLenum srcAlpha;
        GLenum dstAlpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendFuncSeparateiARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFuncSeparateiARB( params->buf, params->srcRGB, params->dstRGB, params->srcAlpha, params->dstAlpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendFunci( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buf;
        GLenum src;
        GLenum dst;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendFunci) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFunci( params->buf, params->src, params->dst );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendFunciARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buf;
        GLenum src;
        GLenum dst;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendFunciARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendFunciARB( params->buf, params->src, params->dst );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlendParameteriNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlendParameteriNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlendParameteriNV( params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlitFramebuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLint srcX0;
        GLint srcY0;
        GLint srcX1;
        GLint srcY1;
        GLint dstX0;
        GLint dstY0;
        GLint dstX1;
        GLint dstY1;
        GLbitfield mask;
        GLenum filter;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlitFramebuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlitFramebuffer( params->srcX0, params->srcY0, params->srcX1, params->srcY1, params->dstX0, params->dstY0, params->dstX1, params->dstY1, params->mask, params->filter );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlitFramebufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint srcX0;
        GLint srcY0;
        GLint srcX1;
        GLint srcY1;
        GLint dstX0;
        GLint dstY0;
        GLint dstX1;
        GLint dstY1;
        GLbitfield mask;
        GLenum filter;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlitFramebufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlitFramebufferEXT( params->srcX0, params->srcY0, params->srcX1, params->srcY1, params->dstX0, params->dstY0, params->dstX1, params->dstY1, params->mask, params->filter );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlitFramebufferLayerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint srcX0;
        GLint srcY0;
        GLint srcX1;
        GLint srcY1;
        GLint srcLayer;
        GLint dstX0;
        GLint dstY0;
        GLint dstX1;
        GLint dstY1;
        GLint dstLayer;
        GLbitfield mask;
        GLenum filter;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlitFramebufferLayerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlitFramebufferLayerEXT( params->srcX0, params->srcY0, params->srcX1, params->srcY1, params->srcLayer, params->dstX0, params->dstY0, params->dstX1, params->dstY1, params->dstLayer, params->mask, params->filter );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlitFramebufferLayersEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint srcX0;
        GLint srcY0;
        GLint srcX1;
        GLint srcY1;
        GLint dstX0;
        GLint dstY0;
        GLint dstX1;
        GLint dstY1;
        GLbitfield mask;
        GLenum filter;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlitFramebufferLayersEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBlitFramebufferLayersEXT( params->srcX0, params->srcY0, params->srcX1, params->srcY1, params->dstX0, params->dstY0, params->dstX1, params->dstY1, params->mask, params->filter );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBlitNamedFramebuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint readFramebuffer;
        GLuint drawFramebuffer;
        GLint srcX0;
        GLint srcY0;
        GLint srcX1;
        GLint srcY1;
        GLint dstX0;
        GLint dstY0;
        GLint dstX1;
        GLint dstY1;
        GLbitfield mask;
        GLenum filter;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint readFramebuffer = params->readFramebuffer;
    GLuint drawFramebuffer = params->drawFramebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBlitNamedFramebuffer) return STATUS_NOT_IMPLEMENTED;
    if (!readFramebuffer) readFramebuffer = get_default_fbo( teb, GL_READ_FRAMEBUFFER );
    if (!drawFramebuffer) drawFramebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glBlitNamedFramebuffer( readFramebuffer, drawFramebuffer, params->srcX0, params->srcY0, params->srcX1, params->srcY1, params->dstX0, params->dstY0, params->dstX1, params->dstY1, params->mask, params->filter );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBufferAddressRangeNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLuint index;
        GLuint64EXT address;
        PTR32 length;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBufferAddressRangeNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferAddressRangeNV( params->pname, params->index, params->address, (GLsizeiptr)ULongToPtr(params->length) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBufferAttachMemoryNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint memory;
        GLuint64 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBufferAttachMemoryNV) return STATUS_NOT_IMPLEMENTED;
    wow64_glBufferAttachMemoryNV( teb, params->target, params->memory, params->offset, funcs->p_glBufferAttachMemoryNV );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBufferData( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 size;
        PTR32 data;
        GLenum usage;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBufferData) return STATUS_NOT_IMPLEMENTED;
    wow64_glBufferData( teb, params->target, (GLsizeiptr)ULongToPtr(params->size), ULongToPtr(params->data), params->usage, funcs->p_glBufferData );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBufferDataARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 size;
        PTR32 data;
        GLenum usage;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBufferDataARB) return STATUS_NOT_IMPLEMENTED;
    wow64_glBufferData( teb, params->target, (GLsizeiptrARB)ULongToPtr(params->size), ULongToPtr(params->data), params->usage, funcs->p_glBufferDataARB );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBufferPageCommitmentARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 offset;
        PTR32 size;
        GLboolean commit;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBufferPageCommitmentARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferPageCommitmentARB( params->target, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBufferPageCommitmentMemNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 offset;
        PTR32 size;
        GLuint memory;
        GLuint64 memOffset;
        GLboolean commit;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBufferPageCommitmentMemNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferPageCommitmentMemNV( params->target, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), params->memory, params->memOffset, params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBufferParameteriAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBufferParameteriAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferParameteriAPPLE( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBufferRegionEnabled( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBufferRegionEnabled) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glBufferRegionEnabled();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBufferStorage( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 size;
        PTR32 data;
        GLbitfield flags;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBufferStorage) return STATUS_NOT_IMPLEMENTED;
    wow64_glBufferStorage( teb, params->target, (GLsizeiptr)ULongToPtr(params->size), ULongToPtr(params->data), params->flags, funcs->p_glBufferStorage );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBufferStorageMemEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 size;
        GLuint memory;
        GLuint64 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBufferStorageMemEXT) return STATUS_NOT_IMPLEMENTED;
    wow64_glBufferStorageMemEXT( teb, params->target, (GLsizeiptr)ULongToPtr(params->size), params->memory, params->offset, funcs->p_glBufferStorageMemEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBufferSubData( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 offset;
        PTR32 size;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferSubData( params->target, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glBufferSubDataARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 offset;
        PTR32 size;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glBufferSubDataARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glBufferSubDataARB( params->target, (GLintptrARB)ULongToPtr(params->offset), (GLsizeiptrARB)ULongToPtr(params->size), ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCallCommandListNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint list;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCallCommandListNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCallCommandListNV( params->list );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCheckFramebufferStatus( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCheckFramebufferStatus) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCheckFramebufferStatus( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCheckFramebufferStatusEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCheckFramebufferStatusEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCheckFramebufferStatusEXT( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCheckNamedFramebufferStatus( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum target;
        GLenum ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCheckNamedFramebufferStatus) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, params->target );
    params->ret = funcs->p_glCheckNamedFramebufferStatus( framebuffer, params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCheckNamedFramebufferStatusEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum target;
        GLenum ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCheckNamedFramebufferStatusEXT) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, params->target );
    params->ret = funcs->p_glCheckNamedFramebufferStatusEXT( framebuffer, params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClampColor( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum clamp;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClampColor) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClampColor( params->target, params->clamp );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClampColorARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum clamp;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClampColorARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClampColorARB( params->target, params->clamp );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearAccumxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed red;
        GLfixed green;
        GLfixed blue;
        GLfixed alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearAccumxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearAccumxOES( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearBufferData( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLenum format;
        GLenum type;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearBufferData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearBufferData( params->target, params->internalformat, params->format, params->type, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearBufferSubData( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        PTR32 offset;
        PTR32 size;
        GLenum format;
        GLenum type;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearBufferSubData( params->target, params->internalformat, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), params->format, params->type, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearBufferfi( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum buffer;
        GLint drawbuffer;
        GLfloat depth;
        GLint stencil;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearBufferfi) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearBufferfi( params->buffer, params->drawbuffer, params->depth, params->stencil );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearBufferfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum buffer;
        GLint drawbuffer;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearBufferfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearBufferfv( params->buffer, params->drawbuffer, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearBufferiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum buffer;
        GLint drawbuffer;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearBufferiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearBufferiv( params->buffer, params->drawbuffer, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearBufferuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum buffer;
        GLint drawbuffer;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearBufferuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearBufferuiv( params->buffer, params->drawbuffer, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearColorIiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint red;
        GLint green;
        GLint blue;
        GLint alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearColorIiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearColorIiEXT( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearColorIuiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint red;
        GLuint green;
        GLuint blue;
        GLuint alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearColorIuiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearColorIuiEXT( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearColorx( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed red;
        GLfixed green;
        GLfixed blue;
        GLfixed alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearColorx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearColorx( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearColorxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed red;
        GLfixed green;
        GLfixed blue;
        GLfixed alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearColorxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearColorxOES( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearDepthdNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble depth;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearDepthdNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearDepthdNV( params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearDepthf( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat d;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearDepthf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearDepthf( params->d );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearDepthfOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLclampf depth;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearDepthfOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearDepthfOES( params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearDepthx( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed depth;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearDepthx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearDepthx( params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearDepthxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed depth;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearDepthxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearDepthxOES( params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearNamedBufferData( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLenum internalformat;
        GLenum format;
        GLenum type;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearNamedBufferData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearNamedBufferData( params->buffer, params->internalformat, params->format, params->type, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearNamedBufferDataEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLenum internalformat;
        GLenum format;
        GLenum type;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearNamedBufferDataEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearNamedBufferDataEXT( params->buffer, params->internalformat, params->format, params->type, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearNamedBufferSubData( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLenum internalformat;
        PTR32 offset;
        PTR32 size;
        GLenum format;
        GLenum type;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearNamedBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearNamedBufferSubData( params->buffer, params->internalformat, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), params->format, params->type, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearNamedBufferSubDataEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLenum internalformat;
        PTR32 offset;
        PTR32 size;
        GLenum format;
        GLenum type;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearNamedBufferSubDataEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearNamedBufferSubDataEXT( params->buffer, params->internalformat, (GLsizeiptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), params->format, params->type, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearNamedFramebufferfi( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum buffer;
        GLint drawbuffer;
        GLfloat depth;
        GLint stencil;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearNamedFramebufferfi) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glClearNamedFramebufferfi( framebuffer, params->buffer, params->drawbuffer, params->depth, params->stencil );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearNamedFramebufferfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum buffer;
        GLint drawbuffer;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearNamedFramebufferfv) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glClearNamedFramebufferfv( framebuffer, params->buffer, params->drawbuffer, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearNamedFramebufferiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum buffer;
        GLint drawbuffer;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearNamedFramebufferiv) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glClearNamedFramebufferiv( framebuffer, params->buffer, params->drawbuffer, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearNamedFramebufferuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum buffer;
        GLint drawbuffer;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearNamedFramebufferuiv) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glClearNamedFramebufferuiv( framebuffer, params->buffer, params->drawbuffer, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearTexImage( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLenum format;
        GLenum type;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearTexImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearTexImage( params->texture, params->level, params->format, params->type, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClearTexSubImage( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLenum format;
        GLenum type;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClearTexSubImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClearTexSubImage( params->texture, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->type, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClientActiveTexture( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClientActiveTexture) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClientActiveTexture( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClientActiveTextureARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClientActiveTextureARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClientActiveTextureARB( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClientActiveVertexStreamATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClientActiveVertexStreamATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClientActiveVertexStreamATI( params->stream );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClientAttribDefaultEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLbitfield mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClientAttribDefaultEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClientAttribDefaultEXT( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClientWaitSemaphoreui64NVX( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei fenceObjectCount;
        PTR32 semaphoreArray;
        PTR32 fenceValueArray;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClientWaitSemaphoreui64NVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClientWaitSemaphoreui64NVX( params->fenceObjectCount, ULongToPtr(params->semaphoreArray), ULongToPtr(params->fenceValueArray) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClientWaitSync( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 sync;
        GLbitfield flags;
        GLuint64 timeout;
        GLenum ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClientWaitSync) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glClientWaitSync( get_unix_sync( ULongToPtr(params->sync) ), params->flags, params->timeout );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClipControl( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum origin;
        GLenum depth;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClipControl) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClipControl( params->origin, params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClipPlanef( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum p;
        PTR32 eqn;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClipPlanef) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClipPlanef( params->p, ULongToPtr(params->eqn) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClipPlanefOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum plane;
        PTR32 equation;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClipPlanefOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClipPlanefOES( params->plane, ULongToPtr(params->equation) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClipPlanex( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum plane;
        PTR32 equation;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClipPlanex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClipPlanex( params->plane, ULongToPtr(params->equation) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glClipPlanexOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum plane;
        PTR32 equation;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glClipPlanexOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glClipPlanexOES( params->plane, ULongToPtr(params->equation) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor3fVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat r;
        GLfloat g;
        GLfloat b;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3fVertex3fSUN( params->r, params->g, params->b, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor3fVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 c;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3fVertex3fvSUN( ULongToPtr(params->c), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor3hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLhalfNV red;
        GLhalfNV green;
        GLhalfNV blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3hNV( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor3hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3hvNV( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor3xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed red;
        GLfixed green;
        GLfixed blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3xOES( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor3xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 components;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor3xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor3xvOES( ULongToPtr(params->components) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor4fNormal3fVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat r;
        GLfloat g;
        GLfloat b;
        GLfloat a;
        GLfloat nx;
        GLfloat ny;
        GLfloat nz;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4fNormal3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4fNormal3fVertex3fSUN( params->r, params->g, params->b, params->a, params->nx, params->ny, params->nz, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor4fNormal3fVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 c;
        PTR32 n;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4fNormal3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4fNormal3fVertex3fvSUN( ULongToPtr(params->c), ULongToPtr(params->n), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor4hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLhalfNV red;
        GLhalfNV green;
        GLhalfNV blue;
        GLhalfNV alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4hNV( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor4hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4hvNV( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor4ubVertex2fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLubyte r;
        GLubyte g;
        GLubyte b;
        GLubyte a;
        GLfloat x;
        GLfloat y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4ubVertex2fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4ubVertex2fSUN( params->r, params->g, params->b, params->a, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor4ubVertex2fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 c;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4ubVertex2fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4ubVertex2fvSUN( ULongToPtr(params->c), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor4ubVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLubyte r;
        GLubyte g;
        GLubyte b;
        GLubyte a;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4ubVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4ubVertex3fSUN( params->r, params->g, params->b, params->a, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor4ubVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 c;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4ubVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4ubVertex3fvSUN( ULongToPtr(params->c), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor4x( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed red;
        GLfixed green;
        GLfixed blue;
        GLfixed alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4x) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4x( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor4xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed red;
        GLfixed green;
        GLfixed blue;
        GLfixed alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4xOES( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColor4xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 components;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColor4xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColor4xvOES( ULongToPtr(params->components) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorFormatNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorFormatNV( params->size, params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorFragmentOp1ATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum op;
        GLuint dst;
        GLuint dstMask;
        GLuint dstMod;
        GLuint arg1;
        GLuint arg1Rep;
        GLuint arg1Mod;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorFragmentOp1ATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorFragmentOp1ATI( params->op, params->dst, params->dstMask, params->dstMod, params->arg1, params->arg1Rep, params->arg1Mod );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorFragmentOp2ATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum op;
        GLuint dst;
        GLuint dstMask;
        GLuint dstMod;
        GLuint arg1;
        GLuint arg1Rep;
        GLuint arg1Mod;
        GLuint arg2;
        GLuint arg2Rep;
        GLuint arg2Mod;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorFragmentOp2ATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorFragmentOp2ATI( params->op, params->dst, params->dstMask, params->dstMod, params->arg1, params->arg1Rep, params->arg1Mod, params->arg2, params->arg2Rep, params->arg2Mod );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorFragmentOp3ATI( void *args )
{
    struct
    {
        PTR32 teb;
        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;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorFragmentOp3ATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorFragmentOp3ATI( params->op, params->dst, params->dstMask, params->dstMod, params->arg1, params->arg1Rep, params->arg1Mod, params->arg2, params->arg2Rep, params->arg2Mod, params->arg3, params->arg3Rep, params->arg3Mod );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorMaskIndexedEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLboolean r;
        GLboolean g;
        GLboolean b;
        GLboolean a;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorMaskIndexedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorMaskIndexedEXT( params->index, params->r, params->g, params->b, params->a );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorMaski( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLboolean r;
        GLboolean g;
        GLboolean b;
        GLboolean a;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorMaski) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorMaski( params->index, params->r, params->g, params->b, params->a );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorP3ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLuint color;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorP3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorP3ui( params->type, params->color );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorP3uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        PTR32 color;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorP3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorP3uiv( params->type, ULongToPtr(params->color) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorP4ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLuint color;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorP4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorP4ui( params->type, params->color );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorP4uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        PTR32 color;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorP4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorP4uiv( params->type, ULongToPtr(params->color) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorPointerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLsizei stride;
        GLsizei count;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorPointerEXT( params->size, params->type, params->stride, params->count, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorPointerListIBM( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLint stride;
        PTR32 pointer;
        GLint ptrstride;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glColorPointervINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        PTR32 pointer;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glColorSubTable( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei start;
        GLsizei count;
        GLenum format;
        GLenum type;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorSubTable) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorSubTable( params->target, params->start, params->count, params->format, params->type, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorSubTableEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei start;
        GLsizei count;
        GLenum format;
        GLenum type;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorSubTableEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorSubTableEXT( params->target, params->start, params->count, params->format, params->type, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorTable( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLsizei width;
        GLenum format;
        GLenum type;
        PTR32 table;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorTable) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorTable( params->target, params->internalformat, params->width, params->format, params->type, ULongToPtr(params->table) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorTableEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalFormat;
        GLsizei width;
        GLenum format;
        GLenum type;
        PTR32 table;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorTableEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorTableEXT( params->target, params->internalFormat, params->width, params->format, params->type, ULongToPtr(params->table) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorTableParameterfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorTableParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorTableParameterfv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorTableParameterfvSGI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorTableParameterfvSGI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorTableParameterfvSGI( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorTableParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorTableParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorTableParameteriv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorTableParameterivSGI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorTableParameterivSGI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorTableParameterivSGI( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glColorTableSGI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLsizei width;
        GLenum format;
        GLenum type;
        PTR32 table;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glColorTableSGI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glColorTableSGI( params->target, params->internalformat, params->width, params->format, params->type, ULongToPtr(params->table) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCombinerInputNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stage;
        GLenum portion;
        GLenum variable;
        GLenum input;
        GLenum mapping;
        GLenum componentUsage;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCombinerInputNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCombinerInputNV( params->stage, params->portion, params->variable, params->input, params->mapping, params->componentUsage );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCombinerOutputNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stage;
        GLenum portion;
        GLenum abOutput;
        GLenum cdOutput;
        GLenum sumOutput;
        GLenum scale;
        GLenum bias;
        GLboolean abDotProduct;
        GLboolean cdDotProduct;
        GLboolean muxSum;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCombinerOutputNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCombinerOutputNV( params->stage, params->portion, params->abOutput, params->cdOutput, params->sumOutput, params->scale, params->bias, params->abDotProduct, params->cdDotProduct, params->muxSum );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCombinerParameterfNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCombinerParameterfNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCombinerParameterfNV( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCombinerParameterfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCombinerParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCombinerParameterfvNV( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCombinerParameteriNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCombinerParameteriNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCombinerParameteriNV( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCombinerParameterivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCombinerParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCombinerParameterivNV( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCombinerStageParameterfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stage;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCombinerStageParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCombinerStageParameterfvNV( params->stage, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCommandListSegmentsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint list;
        GLuint segments;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCommandListSegmentsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCommandListSegmentsNV( params->list, params->segments );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompileCommandListNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint list;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompileCommandListNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompileCommandListNV( params->list );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompileShader( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint shader;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompileShader) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompileShader( params->shader );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompileShaderARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB shaderObj;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompileShaderARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompileShaderARB( params->shaderObj );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompileShaderIncludeARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint shader;
        GLsizei count;
        PTR32 path;
        PTR32 length;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const GLchar **path;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompileShaderIncludeARB) return STATUS_NOT_IMPLEMENTED;
    path = copy_wow64_ptr32s( params->path, params->count );
    funcs->p_glCompileShaderIncludeARB( params->shader, params->count, path, ULongToPtr(params->length) );
    free( path );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedMultiTexImage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLsizei width;
        GLint border;
        GLsizei imageSize;
        PTR32 bits;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedMultiTexImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedMultiTexImage1DEXT( params->texunit, params->target, params->level, params->internalformat, params->width, params->border, params->imageSize, ULongToPtr(params->bits) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedMultiTexImage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLint border;
        GLsizei imageSize;
        PTR32 bits;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedMultiTexImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedMultiTexImage2DEXT( params->texunit, params->target, params->level, params->internalformat, params->width, params->height, params->border, params->imageSize, ULongToPtr(params->bits) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedMultiTexImage3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLint border;
        GLsizei imageSize;
        PTR32 bits;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedMultiTexImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedMultiTexImage3DEXT( params->texunit, params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->border, params->imageSize, ULongToPtr(params->bits) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedMultiTexSubImage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLsizei width;
        GLenum format;
        GLsizei imageSize;
        PTR32 bits;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedMultiTexSubImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedMultiTexSubImage1DEXT( params->texunit, params->target, params->level, params->xoffset, params->width, params->format, params->imageSize, ULongToPtr(params->bits) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedMultiTexSubImage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLsizei imageSize;
        PTR32 bits;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedMultiTexSubImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedMultiTexSubImage2DEXT( params->texunit, params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->imageSize, ULongToPtr(params->bits) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedMultiTexSubImage3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLenum format;
        GLsizei imageSize;
        PTR32 bits;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedMultiTexSubImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedMultiTexSubImage3DEXT( params->texunit, params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->imageSize, ULongToPtr(params->bits) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTexImage1D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLsizei width;
        GLint border;
        GLsizei imageSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTexImage1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexImage1D( params->target, params->level, params->internalformat, params->width, params->border, params->imageSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTexImage1DARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLsizei width;
        GLint border;
        GLsizei imageSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTexImage1DARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexImage1DARB( params->target, params->level, params->internalformat, params->width, params->border, params->imageSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTexImage2D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLint border;
        GLsizei imageSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTexImage2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexImage2D( params->target, params->level, params->internalformat, params->width, params->height, params->border, params->imageSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTexImage2DARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLint border;
        GLsizei imageSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTexImage2DARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexImage2DARB( params->target, params->level, params->internalformat, params->width, params->height, params->border, params->imageSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTexImage3D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLint border;
        GLsizei imageSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTexImage3D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexImage3D( params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->border, params->imageSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTexImage3DARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLint border;
        GLsizei imageSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTexImage3DARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexImage3DARB( params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->border, params->imageSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTexSubImage1D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLsizei width;
        GLenum format;
        GLsizei imageSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTexSubImage1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexSubImage1D( params->target, params->level, params->xoffset, params->width, params->format, params->imageSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTexSubImage1DARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLsizei width;
        GLenum format;
        GLsizei imageSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTexSubImage1DARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexSubImage1DARB( params->target, params->level, params->xoffset, params->width, params->format, params->imageSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTexSubImage2D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLsizei imageSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTexSubImage2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexSubImage2D( params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->imageSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTexSubImage2DARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLsizei imageSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTexSubImage2DARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexSubImage2DARB( params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->imageSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTexSubImage3D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLenum format;
        GLsizei imageSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTexSubImage3D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexSubImage3D( params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->imageSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTexSubImage3DARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLenum format;
        GLsizei imageSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTexSubImage3DARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTexSubImage3DARB( params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->imageSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTextureImage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLsizei width;
        GLint border;
        GLsizei imageSize;
        PTR32 bits;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTextureImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureImage1DEXT( params->texture, params->target, params->level, params->internalformat, params->width, params->border, params->imageSize, ULongToPtr(params->bits) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTextureImage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLint border;
        GLsizei imageSize;
        PTR32 bits;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTextureImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureImage2DEXT( params->texture, params->target, params->level, params->internalformat, params->width, params->height, params->border, params->imageSize, ULongToPtr(params->bits) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTextureImage3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLint border;
        GLsizei imageSize;
        PTR32 bits;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTextureImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureImage3DEXT( params->texture, params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->border, params->imageSize, ULongToPtr(params->bits) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTextureSubImage1D( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLint xoffset;
        GLsizei width;
        GLenum format;
        GLsizei imageSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTextureSubImage1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureSubImage1D( params->texture, params->level, params->xoffset, params->width, params->format, params->imageSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTextureSubImage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLsizei width;
        GLenum format;
        GLsizei imageSize;
        PTR32 bits;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTextureSubImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureSubImage1DEXT( params->texture, params->target, params->level, params->xoffset, params->width, params->format, params->imageSize, ULongToPtr(params->bits) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTextureSubImage2D( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLsizei imageSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTextureSubImage2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureSubImage2D( params->texture, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->imageSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTextureSubImage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLsizei imageSize;
        PTR32 bits;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTextureSubImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureSubImage2DEXT( params->texture, params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->imageSize, ULongToPtr(params->bits) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTextureSubImage3D( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLenum format;
        GLsizei imageSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTextureSubImage3D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureSubImage3D( params->texture, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->imageSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCompressedTextureSubImage3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLenum format;
        GLsizei imageSize;
        PTR32 bits;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCompressedTextureSubImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCompressedTextureSubImage3DEXT( params->texture, params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->imageSize, ULongToPtr(params->bits) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glConservativeRasterParameterfNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfloat value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glConservativeRasterParameterfNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConservativeRasterParameterfNV( params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glConservativeRasterParameteriNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glConservativeRasterParameteriNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConservativeRasterParameteriNV( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glConvolutionFilter1D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLsizei width;
        GLenum format;
        GLenum type;
        PTR32 image;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glConvolutionFilter1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionFilter1D( params->target, params->internalformat, params->width, params->format, params->type, ULongToPtr(params->image) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glConvolutionFilter1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLsizei width;
        GLenum format;
        GLenum type;
        PTR32 image;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glConvolutionFilter1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionFilter1DEXT( params->target, params->internalformat, params->width, params->format, params->type, ULongToPtr(params->image) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glConvolutionFilter2D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLenum type;
        PTR32 image;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glConvolutionFilter2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionFilter2D( params->target, params->internalformat, params->width, params->height, params->format, params->type, ULongToPtr(params->image) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glConvolutionFilter2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLenum type;
        PTR32 image;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glConvolutionFilter2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionFilter2DEXT( params->target, params->internalformat, params->width, params->height, params->format, params->type, ULongToPtr(params->image) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glConvolutionParameterf( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLfloat params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glConvolutionParameterf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameterf( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glConvolutionParameterfEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLfloat params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glConvolutionParameterfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameterfEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glConvolutionParameterfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glConvolutionParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameterfv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glConvolutionParameterfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glConvolutionParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameterfvEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glConvolutionParameteri( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLint params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glConvolutionParameteri) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameteri( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glConvolutionParameteriEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLint params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glConvolutionParameteriEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameteriEXT( params->target, params->pname, params->params );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glConvolutionParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glConvolutionParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameteriv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glConvolutionParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glConvolutionParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameterivEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glConvolutionParameterxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glConvolutionParameterxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameterxOES( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glConvolutionParameterxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glConvolutionParameterxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glConvolutionParameterxvOES( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyBufferSubData( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum readTarget;
        GLenum writeTarget;
        PTR32 readOffset;
        PTR32 writeOffset;
        PTR32 size;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyBufferSubData( params->readTarget, params->writeTarget, (GLintptr)ULongToPtr(params->readOffset), (GLintptr)ULongToPtr(params->writeOffset), (GLsizeiptr)ULongToPtr(params->size) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyColorSubTable( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei start;
        GLint x;
        GLint y;
        GLsizei width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyColorSubTable) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyColorSubTable( params->target, params->start, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyColorSubTableEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei start;
        GLint x;
        GLint y;
        GLsizei width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyColorSubTableEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyColorSubTableEXT( params->target, params->start, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyColorTable( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLint x;
        GLint y;
        GLsizei width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyColorTable) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyColorTable( params->target, params->internalformat, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyColorTableSGI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLint x;
        GLint y;
        GLsizei width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyColorTableSGI) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyColorTableSGI( params->target, params->internalformat, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyConvolutionFilter1D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLint x;
        GLint y;
        GLsizei width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyConvolutionFilter1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyConvolutionFilter1D( params->target, params->internalformat, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyConvolutionFilter1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLint x;
        GLint y;
        GLsizei width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyConvolutionFilter1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyConvolutionFilter1DEXT( params->target, params->internalformat, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyConvolutionFilter2D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyConvolutionFilter2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyConvolutionFilter2D( params->target, params->internalformat, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyConvolutionFilter2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyConvolutionFilter2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyConvolutionFilter2DEXT( params->target, params->internalformat, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyImageSubData( void *args )
{
    struct
    {
        PTR32 teb;
        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;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyImageSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyImageSubData( params->srcName, params->srcTarget, params->srcLevel, params->srcX, params->srcY, params->srcZ, params->dstName, params->dstTarget, params->dstLevel, params->dstX, params->dstY, params->dstZ, params->srcWidth, params->srcHeight, params->srcDepth );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyImageSubDataNV( void *args )
{
    struct
    {
        PTR32 teb;
        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;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyImageSubDataNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyImageSubDataNV( params->srcName, params->srcTarget, params->srcLevel, params->srcX, params->srcY, params->srcZ, params->dstName, params->dstTarget, params->dstLevel, params->dstX, params->dstY, params->dstZ, params->width, params->height, params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyMultiTexImage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLint x;
        GLint y;
        GLsizei width;
        GLint border;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyMultiTexImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyMultiTexImage1DEXT( params->texunit, params->target, params->level, params->internalformat, params->x, params->y, params->width, params->border );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyMultiTexImage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
        GLint border;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyMultiTexImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyMultiTexImage2DEXT( params->texunit, params->target, params->level, params->internalformat, params->x, params->y, params->width, params->height, params->border );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyMultiTexSubImage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint x;
        GLint y;
        GLsizei width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyMultiTexSubImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyMultiTexSubImage1DEXT( params->texunit, params->target, params->level, params->xoffset, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyMultiTexSubImage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyMultiTexSubImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyMultiTexSubImage2DEXT( params->texunit, params->target, params->level, params->xoffset, params->yoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyMultiTexSubImage3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyMultiTexSubImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyMultiTexSubImage3DEXT( params->texunit, params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyNamedBufferSubData( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint readBuffer;
        GLuint writeBuffer;
        PTR32 readOffset;
        PTR32 writeOffset;
        PTR32 size;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyNamedBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyNamedBufferSubData( params->readBuffer, params->writeBuffer, (GLintptr)ULongToPtr(params->readOffset), (GLintptr)ULongToPtr(params->writeOffset), (GLsizeiptr)ULongToPtr(params->size) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyPathNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint resultPath;
        GLuint srcPath;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyPathNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyPathNV( params->resultPath, params->srcPath );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyTexImage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLint x;
        GLint y;
        GLsizei width;
        GLint border;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTexImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyTexImage1DEXT( params->target, params->level, params->internalformat, params->x, params->y, params->width, params->border );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyTexImage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
        GLint border;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTexImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyTexImage2DEXT( params->target, params->level, params->internalformat, params->x, params->y, params->width, params->height, params->border );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyTexSubImage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint x;
        GLint y;
        GLsizei width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTexSubImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyTexSubImage1DEXT( params->target, params->level, params->xoffset, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyTexSubImage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTexSubImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyTexSubImage2DEXT( params->target, params->level, params->xoffset, params->yoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyTexSubImage3D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTexSubImage3D) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyTexSubImage3D( params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyTexSubImage3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTexSubImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyTexSubImage3DEXT( params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyTextureImage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLint x;
        GLint y;
        GLsizei width;
        GLint border;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTextureImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyTextureImage1DEXT( params->texture, params->target, params->level, params->internalformat, params->x, params->y, params->width, params->border );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyTextureImage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
        GLint border;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTextureImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCopyTextureImage2DEXT( params->texture, params->target, params->level, params->internalformat, params->x, params->y, params->width, params->height, params->border );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyTextureSubImage1D( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLint xoffset;
        GLint x;
        GLint y;
        GLsizei width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTextureSubImage1D) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyTextureSubImage1D( params->texture, params->level, params->xoffset, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyTextureSubImage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint x;
        GLint y;
        GLsizei width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTextureSubImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyTextureSubImage1DEXT( params->texture, params->target, params->level, params->xoffset, params->x, params->y, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyTextureSubImage2D( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTextureSubImage2D) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyTextureSubImage2D( params->texture, params->level, params->xoffset, params->yoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyTextureSubImage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTextureSubImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyTextureSubImage2DEXT( params->texture, params->target, params->level, params->xoffset, params->yoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyTextureSubImage3D( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTextureSubImage3D) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyTextureSubImage3D( params->texture, params->level, params->xoffset, params->yoffset, params->zoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCopyTextureSubImage3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCopyTextureSubImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    resolve_default_fbo( teb, TRUE );
    funcs->p_glCopyTextureSubImage3DEXT( params->texture, params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCoverFillPathInstancedNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei numPaths;
        GLenum pathNameType;
        PTR32 paths;
        GLuint pathBase;
        GLenum coverMode;
        GLenum transformType;
        PTR32 transformValues;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCoverFillPathInstancedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCoverFillPathInstancedNV( params->numPaths, params->pathNameType, ULongToPtr(params->paths), params->pathBase, params->coverMode, params->transformType, ULongToPtr(params->transformValues) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCoverFillPathNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLenum coverMode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCoverFillPathNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCoverFillPathNV( params->path, params->coverMode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCoverStrokePathInstancedNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei numPaths;
        GLenum pathNameType;
        PTR32 paths;
        GLuint pathBase;
        GLenum coverMode;
        GLenum transformType;
        PTR32 transformValues;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCoverStrokePathInstancedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCoverStrokePathInstancedNV( params->numPaths, params->pathNameType, ULongToPtr(params->paths), params->pathBase, params->coverMode, params->transformType, ULongToPtr(params->transformValues) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCoverStrokePathNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLenum coverMode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCoverStrokePathNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCoverStrokePathNV( params->path, params->coverMode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCoverageModulationNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum components;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCoverageModulationNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCoverageModulationNV( params->components );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCoverageModulationTableNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCoverageModulationTableNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCoverageModulationTableNV( params->n, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateBuffers( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 buffers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateBuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateBuffers( params->n, ULongToPtr(params->buffers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateCommandListsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 lists;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateCommandListsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateCommandListsNV( params->n, ULongToPtr(params->lists) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateFramebuffers( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 framebuffers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateFramebuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateFramebuffers( params->n, ULongToPtr(params->framebuffers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateMemoryObjectsEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 memoryObjects;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateMemoryObjectsEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateMemoryObjectsEXT( params->n, ULongToPtr(params->memoryObjects) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreatePerfQueryINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint queryId;
        PTR32 queryHandle;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreatePerfQueryINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreatePerfQueryINTEL( params->queryId, ULongToPtr(params->queryHandle) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateProgram( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateProgram) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCreateProgram();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateProgramObjectARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateProgramObjectARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCreateProgramObjectARB();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateProgramPipelines( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 pipelines;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateProgramPipelines) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateProgramPipelines( params->n, ULongToPtr(params->pipelines) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateProgressFenceNVX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateProgressFenceNVX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCreateProgressFenceNVX();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateQueries( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei n;
        PTR32 ids;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateQueries) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateQueries( params->target, params->n, ULongToPtr(params->ids) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateRenderbuffers( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 renderbuffers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateRenderbuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateRenderbuffers( params->n, ULongToPtr(params->renderbuffers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateSamplers( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 samplers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateSamplers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateSamplers( params->n, ULongToPtr(params->samplers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateSemaphoresNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 semaphores;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateSemaphoresNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateSemaphoresNV( params->n, ULongToPtr(params->semaphores) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateShader( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateShader) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCreateShader( params->type );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateShaderObjectARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum shaderType;
        GLhandleARB ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateShaderObjectARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCreateShaderObjectARB( params->shaderType );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateShaderProgramEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        PTR32 string;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateShaderProgramEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glCreateShaderProgramEXT( params->type, ULongToPtr(params->string) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateShaderProgramv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLsizei count;
        PTR32 strings;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const GLchar **strings;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateShaderProgramv) return STATUS_NOT_IMPLEMENTED;
    strings = copy_wow64_ptr32s( params->strings, params->count );
    params->ret = funcs->p_glCreateShaderProgramv( params->type, params->count, strings );
    free( strings );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateStatesNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 states;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateStatesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateStatesNV( params->n, ULongToPtr(params->states) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateSyncFromCLeventARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 context;
        PTR32 event;
        GLbitfield flags;
        PTR32 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateSyncFromCLeventARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = (UINT_PTR)wrap_glCreateSyncFromCLeventARB( teb, ULongToPtr(params->context), ULongToPtr(params->event), params->flags, UlongToHandle( params->ret ), funcs->p_glCreateSyncFromCLeventARB );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateTextures( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei n;
        PTR32 textures;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateTextures) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateTextures( params->target, params->n, ULongToPtr(params->textures) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateTransformFeedbacks( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 ids;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateTransformFeedbacks) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateTransformFeedbacks( params->n, ULongToPtr(params->ids) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCreateVertexArrays( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 arrays;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCreateVertexArrays) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCreateVertexArrays( params->n, ULongToPtr(params->arrays) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCullParameterdvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCullParameterdvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCullParameterdvEXT( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCullParameterfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCullParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCullParameterfvEXT( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glCurrentPaletteMatrixARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glCurrentPaletteMatrixARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glCurrentPaletteMatrixARB( params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDebugMessageCallback( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 callback;
        PTR32 userParam;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDebugMessageCallback) return STATUS_NOT_IMPLEMENTED;
    wrap_glDebugMessageCallback( teb, ULongToPtr(params->callback), ULongToPtr(params->userParam), funcs->p_glDebugMessageCallback );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDebugMessageCallbackAMD( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 callback;
        PTR32 userParam;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDebugMessageCallbackAMD) return STATUS_NOT_IMPLEMENTED;
    wrap_glDebugMessageCallbackAMD( teb, ULongToPtr(params->callback), ULongToPtr(params->userParam), funcs->p_glDebugMessageCallbackAMD );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDebugMessageCallbackARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 callback;
        PTR32 userParam;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDebugMessageCallbackARB) return STATUS_NOT_IMPLEMENTED;
    wrap_glDebugMessageCallback( teb, ULongToPtr(params->callback), ULongToPtr(params->userParam), funcs->p_glDebugMessageCallbackARB );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDebugMessageControl( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum source;
        GLenum type;
        GLenum severity;
        GLsizei count;
        PTR32 ids;
        GLboolean enabled;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDebugMessageControl) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDebugMessageControl( params->source, params->type, params->severity, params->count, ULongToPtr(params->ids), params->enabled );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDebugMessageControlARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum source;
        GLenum type;
        GLenum severity;
        GLsizei count;
        PTR32 ids;
        GLboolean enabled;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDebugMessageControlARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDebugMessageControlARB( params->source, params->type, params->severity, params->count, ULongToPtr(params->ids), params->enabled );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDebugMessageEnableAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum category;
        GLenum severity;
        GLsizei count;
        PTR32 ids;
        GLboolean enabled;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDebugMessageEnableAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDebugMessageEnableAMD( params->category, params->severity, params->count, ULongToPtr(params->ids), params->enabled );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDebugMessageInsert( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum source;
        GLenum type;
        GLuint id;
        GLenum severity;
        GLsizei length;
        PTR32 buf;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDebugMessageInsert) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDebugMessageInsert( params->source, params->type, params->id, params->severity, params->length, ULongToPtr(params->buf) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDebugMessageInsertAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum category;
        GLenum severity;
        GLuint id;
        GLsizei length;
        PTR32 buf;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDebugMessageInsertAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDebugMessageInsertAMD( params->category, params->severity, params->id, params->length, ULongToPtr(params->buf) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDebugMessageInsertARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum source;
        GLenum type;
        GLuint id;
        GLenum severity;
        GLsizei length;
        PTR32 buf;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDebugMessageInsertARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDebugMessageInsertARB( params->source, params->type, params->id, params->severity, params->length, ULongToPtr(params->buf) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeformSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLbitfield mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeformSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeformSGIX( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeformationMap3dSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        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;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeformationMap3dSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeformationMap3dSGIX( params->target, params->u1, params->u2, params->ustride, params->uorder, params->v1, params->v2, params->vstride, params->vorder, params->w1, params->w2, params->wstride, params->worder, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeformationMap3fSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        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;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeformationMap3fSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeformationMap3fSGIX( params->target, params->u1, params->u2, params->ustride, params->uorder, params->v1, params->v2, params->vstride, params->vorder, params->w1, params->w2, params->wstride, params->worder, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteAsyncMarkersSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint marker;
        GLsizei range;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteAsyncMarkersSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteAsyncMarkersSGIX( params->marker, params->range );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteBufferRegion( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum region;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteBufferRegion) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteBufferRegion( params->region );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteBuffers( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 buffers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteBuffers) return STATUS_NOT_IMPLEMENTED;
    wow64_glDeleteBuffers( teb, params->n, ULongToPtr(params->buffers), funcs->p_glDeleteBuffers );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteBuffersARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 buffers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteBuffersARB) return STATUS_NOT_IMPLEMENTED;
    wow64_glDeleteBuffers( teb, params->n, ULongToPtr(params->buffers), funcs->p_glDeleteBuffersARB );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteCommandListsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 lists;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteCommandListsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteCommandListsNV( params->n, ULongToPtr(params->lists) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteFencesAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 fences;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteFencesAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteFencesAPPLE( params->n, ULongToPtr(params->fences) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteFencesNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 fences;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteFencesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteFencesNV( params->n, ULongToPtr(params->fences) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteFragmentShaderATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteFragmentShaderATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteFragmentShaderATI( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteFramebuffers( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 framebuffers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteFramebuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteFramebuffers( params->n, ULongToPtr(params->framebuffers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteFramebuffersEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 framebuffers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteFramebuffersEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteFramebuffersEXT( params->n, ULongToPtr(params->framebuffers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteMemoryObjectsEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 memoryObjects;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteMemoryObjectsEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteMemoryObjectsEXT( params->n, ULongToPtr(params->memoryObjects) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteNamedStringARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint namelen;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteNamedStringARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteNamedStringARB( params->namelen, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteNamesAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum identifier;
        GLuint num;
        PTR32 names;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteNamesAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteNamesAMD( params->identifier, params->num, ULongToPtr(params->names) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteObjectARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB obj;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteObjectARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteObjectARB( params->obj );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteObjectBufferATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteObjectBufferATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteObjectBufferATI( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteOcclusionQueriesNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 ids;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteOcclusionQueriesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteOcclusionQueriesNV( params->n, ULongToPtr(params->ids) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeletePathsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLsizei range;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeletePathsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeletePathsNV( params->path, params->range );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeletePerfMonitorsAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 monitors;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeletePerfMonitorsAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeletePerfMonitorsAMD( params->n, ULongToPtr(params->monitors) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeletePerfQueryINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint queryHandle;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeletePerfQueryINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeletePerfQueryINTEL( params->queryHandle );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteProgram( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteProgram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteProgram( params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteProgramPipelines( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 pipelines;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteProgramPipelines) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteProgramPipelines( params->n, ULongToPtr(params->pipelines) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteProgramsARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 programs;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteProgramsARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteProgramsARB( params->n, ULongToPtr(params->programs) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteProgramsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 programs;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteProgramsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteProgramsNV( params->n, ULongToPtr(params->programs) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteQueries( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 ids;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteQueries) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteQueries( params->n, ULongToPtr(params->ids) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteQueriesARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 ids;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteQueriesARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteQueriesARB( params->n, ULongToPtr(params->ids) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteQueryResourceTagNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 tagIds;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteQueryResourceTagNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteQueryResourceTagNV( params->n, ULongToPtr(params->tagIds) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteRenderbuffers( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 renderbuffers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteRenderbuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteRenderbuffers( params->n, ULongToPtr(params->renderbuffers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteRenderbuffersEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 renderbuffers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteRenderbuffersEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteRenderbuffersEXT( params->n, ULongToPtr(params->renderbuffers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteSamplers( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei count;
        PTR32 samplers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteSamplers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteSamplers( params->count, ULongToPtr(params->samplers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteSemaphoresEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 semaphores;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteSemaphoresEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteSemaphoresEXT( params->n, ULongToPtr(params->semaphores) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteShader( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint shader;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteShader) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteShader( params->shader );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteStatesNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 states;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteStatesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteStatesNV( params->n, ULongToPtr(params->states) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteSync( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 sync;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteSync) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteSync( get_unix_sync( ULongToPtr(params->sync) ) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteTexturesEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 textures;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteTexturesEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteTexturesEXT( params->n, ULongToPtr(params->textures) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteTransformFeedbacks( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 ids;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteTransformFeedbacks) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteTransformFeedbacks( params->n, ULongToPtr(params->ids) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteTransformFeedbacksNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 ids;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteTransformFeedbacksNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteTransformFeedbacksNV( params->n, ULongToPtr(params->ids) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteVertexArrays( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 arrays;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteVertexArrays) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteVertexArrays( params->n, ULongToPtr(params->arrays) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteVertexArraysAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 arrays;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteVertexArraysAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteVertexArraysAPPLE( params->n, ULongToPtr(params->arrays) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDeleteVertexShaderEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDeleteVertexShaderEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDeleteVertexShaderEXT( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDepthBoundsEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLclampd zmin;
        GLclampd zmax;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDepthBoundsEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthBoundsEXT( params->zmin, params->zmax );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDepthBoundsdNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble zmin;
        GLdouble zmax;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDepthBoundsdNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthBoundsdNV( params->zmin, params->zmax );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDepthRangeArraydvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint first;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDepthRangeArraydvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangeArraydvNV( params->first, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDepthRangeArrayv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint first;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDepthRangeArrayv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangeArrayv( params->first, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDepthRangeIndexed( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble n;
        GLdouble f;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDepthRangeIndexed) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangeIndexed( params->index, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDepthRangeIndexeddNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble n;
        GLdouble f;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDepthRangeIndexeddNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangeIndexeddNV( params->index, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDepthRangedNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble zNear;
        GLdouble zFar;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDepthRangedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangedNV( params->zNear, params->zFar );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDepthRangef( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat n;
        GLfloat f;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDepthRangef) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangef( params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDepthRangefOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLclampf n;
        GLclampf f;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDepthRangefOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangefOES( params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDepthRangex( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed n;
        GLfixed f;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDepthRangex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangex( params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDepthRangexOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed n;
        GLfixed f;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDepthRangexOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDepthRangexOES( params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDetachObjectARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB containerObj;
        GLhandleARB attachedObj;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDetachObjectARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDetachObjectARB( params->containerObj, params->attachedObj );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDetachShader( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint shader;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDetachShader) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDetachShader( params->program, params->shader );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDetailTexFuncSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei n;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDetailTexFuncSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDetailTexFuncSGIS( params->target, params->n, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDisableClientStateIndexedEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum array;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDisableClientStateIndexedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableClientStateIndexedEXT( params->array, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDisableClientStateiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum array;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDisableClientStateiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableClientStateiEXT( params->array, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDisableIndexedEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDisableIndexedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableIndexedEXT( params->target, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDisableVariantClientStateEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDisableVariantClientStateEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableVariantClientStateEXT( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDisableVertexArrayAttrib( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDisableVertexArrayAttrib) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableVertexArrayAttrib( params->vaobj, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDisableVertexArrayAttribEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDisableVertexArrayAttribEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableVertexArrayAttribEXT( params->vaobj, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDisableVertexArrayEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLenum array;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDisableVertexArrayEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableVertexArrayEXT( params->vaobj, params->array );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDisableVertexAttribAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDisableVertexAttribAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableVertexAttribAPPLE( params->index, params->pname );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDisableVertexAttribArray( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDisableVertexAttribArray) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableVertexAttribArray( params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDisableVertexAttribArrayARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDisableVertexAttribArrayARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisableVertexAttribArrayARB( params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDisablei( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDisablei) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDisablei( params->target, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDispatchCompute( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint num_groups_x;
        GLuint num_groups_y;
        GLuint num_groups_z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDispatchCompute) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDispatchCompute( params->num_groups_x, params->num_groups_y, params->num_groups_z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDispatchComputeGroupSizeARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint num_groups_x;
        GLuint num_groups_y;
        GLuint num_groups_z;
        GLuint group_size_x;
        GLuint group_size_y;
        GLuint group_size_z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDispatchComputeGroupSizeARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDispatchComputeGroupSizeARB( params->num_groups_x, params->num_groups_y, params->num_groups_z, params->group_size_x, params->group_size_y, params->group_size_z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDispatchComputeIndirect( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 indirect;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDispatchComputeIndirect) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDispatchComputeIndirect( (GLintptr)ULongToPtr(params->indirect) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawArraysEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLint first;
        GLsizei count;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawArraysEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawArraysEXT( params->mode, params->first, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawArraysIndirect( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 indirect;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawArraysIndirect) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawArraysIndirect( params->mode, ULongToPtr(params->indirect) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawArraysInstanced( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLint first;
        GLsizei count;
        GLsizei instancecount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawArraysInstanced) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawArraysInstanced( params->mode, params->first, params->count, params->instancecount );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawArraysInstancedARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLint first;
        GLsizei count;
        GLsizei primcount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawArraysInstancedARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawArraysInstancedARB( params->mode, params->first, params->count, params->primcount );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawArraysInstancedBaseInstance( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLint first;
        GLsizei count;
        GLsizei instancecount;
        GLuint baseinstance;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawArraysInstancedBaseInstance) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawArraysInstancedBaseInstance( params->mode, params->first, params->count, params->instancecount, params->baseinstance );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawArraysInstancedEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLint start;
        GLsizei count;
        GLsizei primcount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawArraysInstancedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawArraysInstancedEXT( params->mode, params->start, params->count, params->primcount );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawBufferRegion( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum region;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
        GLint xDest;
        GLint yDest;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawBufferRegion) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawBufferRegion( params->region, params->x, params->y, params->width, params->height, params->xDest, params->yDest );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawBuffers( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 bufs;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawBuffers) return STATUS_NOT_IMPLEMENTED;
    wrap_glDrawBuffers( teb, params->n, ULongToPtr(params->bufs), funcs->p_glDrawBuffers );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawBuffersARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 bufs;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawBuffersARB) return STATUS_NOT_IMPLEMENTED;
    wrap_glDrawBuffers( teb, params->n, ULongToPtr(params->bufs), funcs->p_glDrawBuffersARB );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawBuffersATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 bufs;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawBuffersATI) return STATUS_NOT_IMPLEMENTED;
    wrap_glDrawBuffers( teb, params->n, ULongToPtr(params->bufs), funcs->p_glDrawBuffersATI );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawCommandsAddressNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum primitiveMode;
        PTR32 indirects;
        PTR32 sizes;
        GLuint count;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawCommandsAddressNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawCommandsAddressNV( params->primitiveMode, ULongToPtr(params->indirects), ULongToPtr(params->sizes), params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawCommandsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum primitiveMode;
        GLuint buffer;
        PTR32 indirects;
        PTR32 sizes;
        GLuint count;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLintptr *indirects;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawCommandsNV) return STATUS_NOT_IMPLEMENTED;
    indirects = copy_wow64_ptr32s( params->indirects, params->count );
    funcs->p_glDrawCommandsNV( params->primitiveMode, params->buffer, indirects, ULongToPtr(params->sizes), params->count );
    free( indirects );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawCommandsStatesAddressNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 indirects;
        PTR32 sizes;
        PTR32 states;
        PTR32 fbos;
        GLuint count;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawCommandsStatesAddressNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawCommandsStatesAddressNV( ULongToPtr(params->indirects), ULongToPtr(params->sizes), ULongToPtr(params->states), ULongToPtr(params->fbos), params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawCommandsStatesNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 indirects;
        PTR32 sizes;
        PTR32 states;
        PTR32 fbos;
        GLuint count;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLintptr *indirects;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawCommandsStatesNV) return STATUS_NOT_IMPLEMENTED;
    indirects = copy_wow64_ptr32s( params->indirects, params->count );
    funcs->p_glDrawCommandsStatesNV( params->buffer, indirects, ULongToPtr(params->sizes), ULongToPtr(params->states), ULongToPtr(params->fbos), params->count );
    free( indirects );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawElementArrayAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLint first;
        GLsizei count;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawElementArrayAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementArrayAPPLE( params->mode, params->first, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawElementArrayATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLsizei count;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawElementArrayATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementArrayATI( params->mode, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawElementsBaseVertex( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLsizei count;
        GLenum type;
        PTR32 indices;
        GLint basevertex;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawElementsBaseVertex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementsBaseVertex( params->mode, params->count, params->type, ULongToPtr(params->indices), params->basevertex );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawElementsIndirect( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLenum type;
        PTR32 indirect;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawElementsIndirect) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementsIndirect( params->mode, params->type, ULongToPtr(params->indirect) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawElementsInstanced( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLsizei count;
        GLenum type;
        PTR32 indices;
        GLsizei instancecount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawElementsInstanced) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementsInstanced( params->mode, params->count, params->type, ULongToPtr(params->indices), params->instancecount );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawElementsInstancedARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLsizei count;
        GLenum type;
        PTR32 indices;
        GLsizei primcount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawElementsInstancedARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementsInstancedARB( params->mode, params->count, params->type, ULongToPtr(params->indices), params->primcount );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawElementsInstancedBaseInstance( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLsizei count;
        GLenum type;
        PTR32 indices;
        GLsizei instancecount;
        GLuint baseinstance;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawElementsInstancedBaseInstance) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementsInstancedBaseInstance( params->mode, params->count, params->type, ULongToPtr(params->indices), params->instancecount, params->baseinstance );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawElementsInstancedBaseVertex( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLsizei count;
        GLenum type;
        PTR32 indices;
        GLsizei instancecount;
        GLint basevertex;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawElementsInstancedBaseVertex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementsInstancedBaseVertex( params->mode, params->count, params->type, ULongToPtr(params->indices), params->instancecount, params->basevertex );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawElementsInstancedBaseVertexBaseInstance( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLsizei count;
        GLenum type;
        PTR32 indices;
        GLsizei instancecount;
        GLint basevertex;
        GLuint baseinstance;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawElementsInstancedBaseVertexBaseInstance) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementsInstancedBaseVertexBaseInstance( params->mode, params->count, params->type, ULongToPtr(params->indices), params->instancecount, params->basevertex, params->baseinstance );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawElementsInstancedEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLsizei count;
        GLenum type;
        PTR32 indices;
        GLsizei primcount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawElementsInstancedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawElementsInstancedEXT( params->mode, params->count, params->type, ULongToPtr(params->indices), params->primcount );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawMeshArraysSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLint first;
        GLsizei count;
        GLsizei width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawMeshArraysSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawMeshArraysSUN( params->mode, params->first, params->count, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawMeshTasksEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint num_groups_x;
        GLuint num_groups_y;
        GLuint num_groups_z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawMeshTasksEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawMeshTasksEXT( params->num_groups_x, params->num_groups_y, params->num_groups_z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawMeshTasksIndirectEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 indirect;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawMeshTasksIndirectEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawMeshTasksIndirectEXT( (GLintptr)ULongToPtr(params->indirect) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawMeshTasksIndirectNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 indirect;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawMeshTasksIndirectNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawMeshTasksIndirectNV( (GLintptr)ULongToPtr(params->indirect) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawMeshTasksNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint first;
        GLuint count;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawMeshTasksNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawMeshTasksNV( params->first, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawRangeElementArrayAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLuint start;
        GLuint end;
        GLint first;
        GLsizei count;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawRangeElementArrayAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawRangeElementArrayAPPLE( params->mode, params->start, params->end, params->first, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawRangeElementArrayATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLuint start;
        GLuint end;
        GLsizei count;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawRangeElementArrayATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawRangeElementArrayATI( params->mode, params->start, params->end, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawRangeElements( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLuint start;
        GLuint end;
        GLsizei count;
        GLenum type;
        PTR32 indices;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawRangeElements) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawRangeElements( params->mode, params->start, params->end, params->count, params->type, ULongToPtr(params->indices) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawRangeElementsBaseVertex( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLuint start;
        GLuint end;
        GLsizei count;
        GLenum type;
        PTR32 indices;
        GLint basevertex;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawRangeElementsBaseVertex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawRangeElementsBaseVertex( params->mode, params->start, params->end, params->count, params->type, ULongToPtr(params->indices), params->basevertex );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawRangeElementsEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLuint start;
        GLuint end;
        GLsizei count;
        GLenum type;
        PTR32 indices;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawRangeElementsEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawRangeElementsEXT( params->mode, params->start, params->end, params->count, params->type, ULongToPtr(params->indices) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawTextureNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLuint sampler;
        GLfloat x0;
        GLfloat y0;
        GLfloat x1;
        GLfloat y1;
        GLfloat z;
        GLfloat s0;
        GLfloat t0;
        GLfloat s1;
        GLfloat t1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawTextureNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawTextureNV( params->texture, params->sampler, params->x0, params->y0, params->x1, params->y1, params->z, params->s0, params->t0, params->s1, params->t1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawTransformFeedback( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLuint id;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawTransformFeedback) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawTransformFeedback( params->mode, params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawTransformFeedbackInstanced( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLuint id;
        GLsizei instancecount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawTransformFeedbackInstanced) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawTransformFeedbackInstanced( params->mode, params->id, params->instancecount );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawTransformFeedbackNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLuint id;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawTransformFeedbackNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawTransformFeedbackNV( params->mode, params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawTransformFeedbackStream( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLuint id;
        GLuint stream;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawTransformFeedbackStream) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawTransformFeedbackStream( params->mode, params->id, params->stream );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawTransformFeedbackStreamInstanced( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLuint id;
        GLuint stream;
        GLsizei instancecount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawTransformFeedbackStreamInstanced) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawTransformFeedbackStreamInstanced( params->mode, params->id, params->stream, params->instancecount );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glDrawVkImageNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint64 vkImage;
        GLuint sampler;
        GLfloat x0;
        GLfloat y0;
        GLfloat x1;
        GLfloat y1;
        GLfloat z;
        GLfloat s0;
        GLfloat t0;
        GLfloat s1;
        GLfloat t1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glDrawVkImageNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glDrawVkImageNV( params->vkImage, params->sampler, params->x0, params->y0, params->x1, params->y1, params->z, params->s0, params->t0, params->s1, params->t1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEGLImageTargetTexStorageEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 image;
        PTR32 attrib_list;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEGLImageTargetTexStorageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEGLImageTargetTexStorageEXT( params->target, ULongToPtr(params->image), ULongToPtr(params->attrib_list) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEGLImageTargetTextureStorageEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        PTR32 image;
        PTR32 attrib_list;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEGLImageTargetTextureStorageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEGLImageTargetTextureStorageEXT( params->texture, ULongToPtr(params->image), ULongToPtr(params->attrib_list) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEdgeFlagFormatNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEdgeFlagFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEdgeFlagFormatNV( params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEdgeFlagPointerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei stride;
        GLsizei count;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEdgeFlagPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEdgeFlagPointerEXT( params->stride, params->count, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEdgeFlagPointerListIBM( void *args )
{
    struct
    {
        PTR32 teb;
        GLint stride;
        PTR32 pointer;
        GLint ptrstride;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glElementPointerAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glElementPointerAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glElementPointerAPPLE( params->type, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glElementPointerATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glElementPointerATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glElementPointerATI( params->type, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEnableClientStateIndexedEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum array;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEnableClientStateIndexedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableClientStateIndexedEXT( params->array, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEnableClientStateiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum array;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEnableClientStateiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableClientStateiEXT( params->array, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEnableIndexedEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEnableIndexedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableIndexedEXT( params->target, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEnableVariantClientStateEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEnableVariantClientStateEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableVariantClientStateEXT( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEnableVertexArrayAttrib( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEnableVertexArrayAttrib) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableVertexArrayAttrib( params->vaobj, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEnableVertexArrayAttribEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEnableVertexArrayAttribEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableVertexArrayAttribEXT( params->vaobj, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEnableVertexArrayEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLenum array;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEnableVertexArrayEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableVertexArrayEXT( params->vaobj, params->array );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEnableVertexAttribAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEnableVertexAttribAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableVertexAttribAPPLE( params->index, params->pname );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEnableVertexAttribArray( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEnableVertexAttribArray) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableVertexAttribArray( params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEnableVertexAttribArrayARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEnableVertexAttribArrayARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnableVertexAttribArrayARB( params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEnablei( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEnablei) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEnablei( params->target, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEndConditionalRender( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEndConditionalRender) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndConditionalRender();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEndConditionalRenderNV( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEndConditionalRenderNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndConditionalRenderNV();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEndConditionalRenderNVX( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEndConditionalRenderNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndConditionalRenderNVX();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEndFragmentShaderATI( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEndFragmentShaderATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndFragmentShaderATI();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEndOcclusionQueryNV( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEndOcclusionQueryNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndOcclusionQueryNV();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEndPerfMonitorAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint monitor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEndPerfMonitorAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndPerfMonitorAMD( params->monitor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEndPerfQueryINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint queryHandle;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEndPerfQueryINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndPerfQueryINTEL( params->queryHandle );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEndQuery( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEndQuery) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndQuery( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEndQueryARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEndQueryARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndQueryARB( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEndQueryIndexed( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEndQueryIndexed) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndQueryIndexed( params->target, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEndTransformFeedback( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEndTransformFeedback) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndTransformFeedback();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEndTransformFeedbackEXT( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEndTransformFeedbackEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndTransformFeedbackEXT();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEndTransformFeedbackNV( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEndTransformFeedbackNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndTransformFeedbackNV();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEndVertexShaderEXT( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEndVertexShaderEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndVertexShaderEXT();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEndVideoCaptureNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_capture_slot;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEndVideoCaptureNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEndVideoCaptureNV( params->video_capture_slot );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEvalCoord1xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed u;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalCoord1xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord1xOES( params->u );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEvalCoord1xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalCoord1xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord1xvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEvalCoord2xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed u;
        GLfixed v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalCoord2xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord2xOES( params->u, params->v );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEvalCoord2xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalCoord2xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalCoord2xvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEvalMapsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvalMapsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvalMapsNV( params->target, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glEvaluateDepthValuesARB( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glEvaluateDepthValuesARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glEvaluateDepthValuesARB();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glExecuteProgramNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint id;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glExecuteProgramNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glExecuteProgramNV( params->target, params->id, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glExtractComponentEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint res;
        GLuint src;
        GLuint num;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glExtractComponentEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glExtractComponentEXT( params->res, params->src, params->num );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFeedbackBufferxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        GLenum type;
        PTR32 buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFeedbackBufferxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFeedbackBufferxOES( params->n, params->type, ULongToPtr(params->buffer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFenceSync( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum condition;
        GLbitfield flags;
        PTR32 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFenceSync) return STATUS_NOT_IMPLEMENTED;
    params->ret = (UINT_PTR)wrap_glFenceSync( teb, params->condition, params->flags, UlongToHandle( params->ret ), funcs->p_glFenceSync );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFinalCombinerInputNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum variable;
        GLenum input;
        GLenum mapping;
        GLenum componentUsage;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFinalCombinerInputNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFinalCombinerInputNV( params->variable, params->input, params->mapping, params->componentUsage );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFinishAsyncSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 markerp;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFinishAsyncSGIX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glFinishAsyncSGIX( ULongToPtr(params->markerp) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFinishFenceAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint fence;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFinishFenceAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFinishFenceAPPLE( params->fence );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFinishFenceNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint fence;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFinishFenceNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFinishFenceNV( params->fence );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFinishObjectAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum object;
        GLint name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFinishObjectAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFinishObjectAPPLE( params->object, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFinishTextureSUNX( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFinishTextureSUNX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFinishTextureSUNX();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFlushMappedBufferRange( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 offset;
        PTR32 length;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFlushMappedBufferRange) return STATUS_NOT_IMPLEMENTED;
    wow64_glFlushMappedBufferRange( teb, params->target, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->length), funcs->p_glFlushMappedBufferRange );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFlushMappedBufferRangeAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 offset;
        PTR32 size;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFlushMappedBufferRangeAPPLE) return STATUS_NOT_IMPLEMENTED;
    wow64_glFlushMappedBufferRange( teb, params->target, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), funcs->p_glFlushMappedBufferRangeAPPLE );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFlushMappedNamedBufferRange( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 offset;
        PTR32 length;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFlushMappedNamedBufferRange) return STATUS_NOT_IMPLEMENTED;
    wow64_glFlushMappedNamedBufferRange( teb, params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->length), funcs->p_glFlushMappedNamedBufferRange );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFlushMappedNamedBufferRangeEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 offset;
        PTR32 length;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFlushMappedNamedBufferRangeEXT) return STATUS_NOT_IMPLEMENTED;
    wow64_glFlushMappedNamedBufferRange( teb, params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->length), funcs->p_glFlushMappedNamedBufferRangeEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFlushPixelDataRangeNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFlushPixelDataRangeNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFlushPixelDataRangeNV( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFlushRasterSGIX( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFlushRasterSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFlushRasterSGIX();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFlushStaticDataIBM( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFlushStaticDataIBM) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFlushStaticDataIBM( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFlushVertexArrayRangeAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei length;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFlushVertexArrayRangeAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFlushVertexArrayRangeAPPLE( params->length, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFlushVertexArrayRangeNV( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFlushVertexArrayRangeNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFlushVertexArrayRangeNV();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogCoordFormatNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogCoordFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordFormatNV( params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogCoordPointer( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogCoordPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordPointer( params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogCoordPointerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogCoordPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordPointerEXT( params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogCoordPointerListIBM( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLint stride;
        PTR32 pointer;
        GLint ptrstride;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glFogCoordd( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble coord;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogCoordd) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordd( params->coord );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogCoorddEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble coord;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogCoorddEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoorddEXT( params->coord );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogCoorddv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coord;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogCoorddv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoorddv( ULongToPtr(params->coord) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogCoorddvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coord;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogCoorddvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoorddvEXT( ULongToPtr(params->coord) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogCoordf( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat coord;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogCoordf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordf( params->coord );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogCoordfEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat coord;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogCoordfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordfEXT( params->coord );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogCoordfv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coord;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogCoordfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordfv( ULongToPtr(params->coord) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogCoordfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coord;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogCoordfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordfvEXT( ULongToPtr(params->coord) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogCoordhNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLhalfNV fog;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogCoordhNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordhNV( params->fog );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogCoordhvNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 fog;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogCoordhvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogCoordhvNV( ULongToPtr(params->fog) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogFuncSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogFuncSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogFuncSGIS( params->n, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogx( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogx( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogxOES( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogxv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogxv( params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFogxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFogxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFogxvOES( params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFragmentColorMaterialSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFragmentColorMaterialSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentColorMaterialSGIX( params->face, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFragmentCoverageColorNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint color;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFragmentCoverageColorNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentCoverageColorNV( params->color );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFragmentLightModelfSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFragmentLightModelfSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentLightModelfSGIX( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFragmentLightModelfvSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFragmentLightModelfvSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentLightModelfvSGIX( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFragmentLightModeliSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFragmentLightModeliSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentLightModeliSGIX( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFragmentLightModelivSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFragmentLightModelivSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentLightModelivSGIX( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFragmentLightfSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFragmentLightfSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentLightfSGIX( params->light, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFragmentLightfvSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFragmentLightfvSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentLightfvSGIX( params->light, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFragmentLightiSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFragmentLightiSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentLightiSGIX( params->light, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFragmentLightivSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFragmentLightivSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentLightivSGIX( params->light, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFragmentMaterialfSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFragmentMaterialfSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentMaterialfSGIX( params->face, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFragmentMaterialfvSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFragmentMaterialfvSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentMaterialfvSGIX( params->face, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFragmentMaterialiSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFragmentMaterialiSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentMaterialiSGIX( params->face, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFragmentMaterialivSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFragmentMaterialivSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFragmentMaterialivSGIX( params->face, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFrameTerminatorGREMEDY( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFrameTerminatorGREMEDY) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFrameTerminatorGREMEDY();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFrameZoomSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLint factor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFrameZoomSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFrameZoomSGIX( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferDrawBufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferDrawBufferEXT) return STATUS_NOT_IMPLEMENTED;
    wrap_glFramebufferDrawBufferEXT( teb, params->framebuffer, params->mode, funcs->p_glFramebufferDrawBufferEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferDrawBuffersEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLsizei n;
        PTR32 bufs;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferDrawBuffersEXT) return STATUS_NOT_IMPLEMENTED;
    wrap_glFramebufferDrawBuffersEXT( teb, params->framebuffer, params->n, ULongToPtr(params->bufs), funcs->p_glFramebufferDrawBuffersEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferFetchBarrierEXT( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferFetchBarrierEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFramebufferFetchBarrierEXT();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferParameteri( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferParameteri) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFramebufferParameteri( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferParameteriMESA( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferParameteriMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFramebufferParameteriMESA( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferReadBufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferReadBufferEXT) return STATUS_NOT_IMPLEMENTED;
    wrap_glFramebufferReadBufferEXT( teb, params->framebuffer, params->mode, funcs->p_glFramebufferReadBufferEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferRenderbuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLenum renderbuffertarget;
        GLuint renderbuffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferRenderbuffer) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferRenderbuffer( params->target, params->attachment, params->renderbuffertarget, params->renderbuffer );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferRenderbufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLenum renderbuffertarget;
        GLuint renderbuffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferRenderbufferEXT) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferRenderbufferEXT( params->target, params->attachment, params->renderbuffertarget, params->renderbuffer );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferSampleLocationsfvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint start;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferSampleLocationsfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFramebufferSampleLocationsfvARB( params->target, params->start, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferSampleLocationsfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint start;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferSampleLocationsfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFramebufferSampleLocationsfvNV( params->target, params->start, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferSamplePositionsfvAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint numsamples;
        GLuint pixelindex;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferSamplePositionsfvAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFramebufferSamplePositionsfvAMD( params->target, params->numsamples, params->pixelindex, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferShadingRateEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLuint texture;
        GLint baseLayer;
        GLsizei numLayers;
        GLsizei texelWidth;
        GLsizei texelHeight;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferShadingRateEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFramebufferShadingRateEXT( params->target, params->attachment, params->texture, params->baseLayer, params->numLayers, params->texelWidth, params->texelHeight );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferTexture( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLuint texture;
        GLint level;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferTexture) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferTexture( params->target, params->attachment, params->texture, params->level );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferTexture1D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLenum textarget;
        GLuint texture;
        GLint level;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferTexture1D) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferTexture1D( params->target, params->attachment, params->textarget, params->texture, params->level );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferTexture1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLenum textarget;
        GLuint texture;
        GLint level;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferTexture1DEXT) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferTexture1DEXT( params->target, params->attachment, params->textarget, params->texture, params->level );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferTexture2D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLenum textarget;
        GLuint texture;
        GLint level;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferTexture2D) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferTexture2D( params->target, params->attachment, params->textarget, params->texture, params->level );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferTexture2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLenum textarget;
        GLuint texture;
        GLint level;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferTexture2DEXT) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferTexture2DEXT( params->target, params->attachment, params->textarget, params->texture, params->level );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferTexture3D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLenum textarget;
        GLuint texture;
        GLint level;
        GLint zoffset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferTexture3D) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferTexture3D( params->target, params->attachment, params->textarget, params->texture, params->level, params->zoffset );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferTexture3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLenum textarget;
        GLuint texture;
        GLint level;
        GLint zoffset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferTexture3DEXT) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferTexture3DEXT( params->target, params->attachment, params->textarget, params->texture, params->level, params->zoffset );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferTextureARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLuint texture;
        GLint level;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferTextureARB) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferTextureARB( params->target, params->attachment, params->texture, params->level );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferTextureEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLuint texture;
        GLint level;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferTextureEXT) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferTextureEXT( params->target, params->attachment, params->texture, params->level );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferTextureFaceARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLuint texture;
        GLint level;
        GLenum face;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferTextureFaceARB) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferTextureFaceARB( params->target, params->attachment, params->texture, params->level, params->face );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferTextureFaceEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLuint texture;
        GLint level;
        GLenum face;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferTextureFaceEXT) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferTextureFaceEXT( params->target, params->attachment, params->texture, params->level, params->face );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferTextureLayer( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLuint texture;
        GLint level;
        GLint layer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferTextureLayer) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferTextureLayer( params->target, params->attachment, params->texture, params->level, params->layer );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferTextureLayerARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLuint texture;
        GLint level;
        GLint layer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferTextureLayerARB) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferTextureLayerARB( params->target, params->attachment, params->texture, params->level, params->layer );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferTextureLayerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLuint texture;
        GLint level;
        GLint layer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferTextureLayerEXT) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferTextureLayerEXT( params->target, params->attachment, params->texture, params->level, params->layer );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFramebufferTextureMultiviewOVR( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLuint texture;
        GLint level;
        GLint baseViewIndex;
        GLsizei numViews;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFramebufferTextureMultiviewOVR) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glFramebufferTextureMultiviewOVR( params->target, params->attachment, params->texture, params->level, params->baseViewIndex, params->numViews );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFreeObjectBufferATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFreeObjectBufferATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFreeObjectBufferATI( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFrustumf( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat l;
        GLfloat r;
        GLfloat b;
        GLfloat t;
        GLfloat n;
        GLfloat f;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFrustumf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFrustumf( params->l, params->r, params->b, params->t, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFrustumfOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat l;
        GLfloat r;
        GLfloat b;
        GLfloat t;
        GLfloat n;
        GLfloat f;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFrustumfOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFrustumfOES( params->l, params->r, params->b, params->t, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFrustumx( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed l;
        GLfixed r;
        GLfixed b;
        GLfixed t;
        GLfixed n;
        GLfixed f;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFrustumx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFrustumx( params->l, params->r, params->b, params->t, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glFrustumxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed l;
        GLfixed r;
        GLfixed b;
        GLfixed t;
        GLfixed n;
        GLfixed f;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glFrustumxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glFrustumxOES( params->l, params->r, params->b, params->t, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenAsyncMarkersSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei range;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenAsyncMarkersSGIX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGenAsyncMarkersSGIX( params->range );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenBuffers( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 buffers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenBuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenBuffers( params->n, ULongToPtr(params->buffers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenBuffersARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 buffers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenBuffersARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenBuffersARB( params->n, ULongToPtr(params->buffers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenFencesAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 fences;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenFencesAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenFencesAPPLE( params->n, ULongToPtr(params->fences) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenFencesNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 fences;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenFencesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenFencesNV( params->n, ULongToPtr(params->fences) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenFragmentShadersATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint range;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenFragmentShadersATI) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGenFragmentShadersATI( params->range );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenFramebuffers( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 framebuffers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenFramebuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenFramebuffers( params->n, ULongToPtr(params->framebuffers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenFramebuffersEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 framebuffers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenFramebuffersEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenFramebuffersEXT( params->n, ULongToPtr(params->framebuffers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenNamesAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum identifier;
        GLuint num;
        PTR32 names;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenNamesAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenNamesAMD( params->identifier, params->num, ULongToPtr(params->names) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenOcclusionQueriesNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 ids;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenOcclusionQueriesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenOcclusionQueriesNV( params->n, ULongToPtr(params->ids) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenPathsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei range;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenPathsNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGenPathsNV( params->range );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenPerfMonitorsAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 monitors;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenPerfMonitorsAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenPerfMonitorsAMD( params->n, ULongToPtr(params->monitors) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenProgramPipelines( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 pipelines;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenProgramPipelines) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenProgramPipelines( params->n, ULongToPtr(params->pipelines) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenProgramsARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 programs;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenProgramsARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenProgramsARB( params->n, ULongToPtr(params->programs) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenProgramsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 programs;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenProgramsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenProgramsNV( params->n, ULongToPtr(params->programs) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenQueries( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 ids;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenQueries) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenQueries( params->n, ULongToPtr(params->ids) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenQueriesARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 ids;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenQueriesARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenQueriesARB( params->n, ULongToPtr(params->ids) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenQueryResourceTagNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 tagIds;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenQueryResourceTagNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenQueryResourceTagNV( params->n, ULongToPtr(params->tagIds) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenRenderbuffers( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 renderbuffers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenRenderbuffers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenRenderbuffers( params->n, ULongToPtr(params->renderbuffers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenRenderbuffersEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 renderbuffers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenRenderbuffersEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenRenderbuffersEXT( params->n, ULongToPtr(params->renderbuffers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenSamplers( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei count;
        PTR32 samplers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenSamplers) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenSamplers( params->count, ULongToPtr(params->samplers) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenSemaphoresEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 semaphores;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenSemaphoresEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenSemaphoresEXT( params->n, ULongToPtr(params->semaphores) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenSymbolsEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum datatype;
        GLenum storagetype;
        GLenum range;
        GLuint components;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenSymbolsEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGenSymbolsEXT( params->datatype, params->storagetype, params->range, params->components );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenTexturesEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 textures;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenTexturesEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenTexturesEXT( params->n, ULongToPtr(params->textures) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenTransformFeedbacks( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 ids;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenTransformFeedbacks) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenTransformFeedbacks( params->n, ULongToPtr(params->ids) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenTransformFeedbacksNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 ids;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenTransformFeedbacksNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenTransformFeedbacksNV( params->n, ULongToPtr(params->ids) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenVertexArrays( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 arrays;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenVertexArrays) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenVertexArrays( params->n, ULongToPtr(params->arrays) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenVertexArraysAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 arrays;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenVertexArraysAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenVertexArraysAPPLE( params->n, ULongToPtr(params->arrays) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenVertexShadersEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint range;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenVertexShadersEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGenVertexShadersEXT( params->range );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenerateMipmap( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenerateMipmap) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenerateMipmap( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenerateMipmapEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenerateMipmapEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenerateMipmapEXT( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenerateMultiTexMipmapEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenerateMultiTexMipmapEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenerateMultiTexMipmapEXT( params->texunit, params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenerateTextureMipmap( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenerateTextureMipmap) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenerateTextureMipmap( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGenerateTextureMipmapEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGenerateTextureMipmapEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGenerateTextureMipmapEXT( params->texture, params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetActiveAtomicCounterBufferiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint bufferIndex;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetActiveAtomicCounterBufferiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveAtomicCounterBufferiv( params->program, params->bufferIndex, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetActiveAttrib( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint index;
        GLsizei bufSize;
        PTR32 length;
        PTR32 size;
        PTR32 type;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetActiveAttrib) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveAttrib( params->program, params->index, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->size), ULongToPtr(params->type), ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetActiveAttribARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB programObj;
        GLuint index;
        GLsizei maxLength;
        PTR32 length;
        PTR32 size;
        PTR32 type;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetActiveAttribARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveAttribARB( params->programObj, params->index, params->maxLength, ULongToPtr(params->length), ULongToPtr(params->size), ULongToPtr(params->type), ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetActiveSubroutineName( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum shadertype;
        GLuint index;
        GLsizei bufSize;
        PTR32 length;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetActiveSubroutineName) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveSubroutineName( params->program, params->shadertype, params->index, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetActiveSubroutineUniformName( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum shadertype;
        GLuint index;
        GLsizei bufSize;
        PTR32 length;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetActiveSubroutineUniformName) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveSubroutineUniformName( params->program, params->shadertype, params->index, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetActiveSubroutineUniformiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum shadertype;
        GLuint index;
        GLenum pname;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetActiveSubroutineUniformiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveSubroutineUniformiv( params->program, params->shadertype, params->index, params->pname, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetActiveUniform( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint index;
        GLsizei bufSize;
        PTR32 length;
        PTR32 size;
        PTR32 type;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetActiveUniform) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveUniform( params->program, params->index, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->size), ULongToPtr(params->type), ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetActiveUniformARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB programObj;
        GLuint index;
        GLsizei maxLength;
        PTR32 length;
        PTR32 size;
        PTR32 type;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetActiveUniformARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveUniformARB( params->programObj, params->index, params->maxLength, ULongToPtr(params->length), ULongToPtr(params->size), ULongToPtr(params->type), ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetActiveUniformBlockName( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint uniformBlockIndex;
        GLsizei bufSize;
        PTR32 length;
        PTR32 uniformBlockName;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetActiveUniformBlockName) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveUniformBlockName( params->program, params->uniformBlockIndex, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->uniformBlockName) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetActiveUniformBlockiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint uniformBlockIndex;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetActiveUniformBlockiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveUniformBlockiv( params->program, params->uniformBlockIndex, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetActiveUniformName( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint uniformIndex;
        GLsizei bufSize;
        PTR32 length;
        PTR32 uniformName;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetActiveUniformName) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveUniformName( params->program, params->uniformIndex, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->uniformName) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetActiveUniformsiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLsizei uniformCount;
        PTR32 uniformIndices;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetActiveUniformsiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveUniformsiv( params->program, params->uniformCount, ULongToPtr(params->uniformIndices), params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetActiveVaryingNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint index;
        GLsizei bufSize;
        PTR32 length;
        PTR32 size;
        PTR32 type;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetActiveVaryingNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetActiveVaryingNV( params->program, params->index, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->size), ULongToPtr(params->type), ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetArrayObjectfvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum array;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetArrayObjectfvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetArrayObjectfvATI( params->array, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetArrayObjectivATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum array;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetArrayObjectivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetArrayObjectivATI( params->array, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetAttachedObjectsARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB containerObj;
        GLsizei maxCount;
        PTR32 count;
        PTR32 obj;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetAttachedObjectsARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetAttachedObjectsARB( params->containerObj, params->maxCount, ULongToPtr(params->count), ULongToPtr(params->obj) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetAttachedShaders( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLsizei maxCount;
        PTR32 count;
        PTR32 shaders;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetAttachedShaders) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetAttachedShaders( params->program, params->maxCount, ULongToPtr(params->count), ULongToPtr(params->shaders) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetAttribLocation( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        PTR32 name;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetAttribLocation) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetAttribLocation( params->program, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetAttribLocationARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB programObj;
        PTR32 name;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetAttribLocationARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetAttribLocationARB( params->programObj, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetBooleanIndexedvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetBooleanIndexedvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBooleanIndexedvEXT( params->target, params->index, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetBooleani_v( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetBooleani_v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBooleani_v( params->target, params->index, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetBufferParameteri64v( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetBufferParameteri64v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBufferParameteri64v( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetBufferParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetBufferParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBufferParameteriv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetBufferParameterivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetBufferParameterivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBufferParameterivARB( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetBufferParameterui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetBufferParameterui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBufferParameterui64vNV( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetBufferPointerv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetBufferPointerv) return STATUS_NOT_IMPLEMENTED;
    wow64_glGetBufferPointerv( teb, params->target, params->pname, ULongToPtr(params->params), funcs->p_glGetBufferPointerv );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetBufferPointervARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetBufferPointervARB) return STATUS_NOT_IMPLEMENTED;
    wow64_glGetBufferPointerv( teb, params->target, params->pname, ULongToPtr(params->params), funcs->p_glGetBufferPointervARB );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetBufferSubData( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 offset;
        PTR32 size;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBufferSubData( params->target, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetBufferSubDataARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 offset;
        PTR32 size;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetBufferSubDataARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetBufferSubDataARB( params->target, (GLintptrARB)ULongToPtr(params->offset), (GLsizeiptrARB)ULongToPtr(params->size), ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetClipPlanef( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum plane;
        PTR32 equation;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetClipPlanef) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetClipPlanef( params->plane, ULongToPtr(params->equation) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetClipPlanefOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum plane;
        PTR32 equation;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetClipPlanefOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetClipPlanefOES( params->plane, ULongToPtr(params->equation) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetClipPlanex( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum plane;
        PTR32 equation;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetClipPlanex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetClipPlanex( params->plane, ULongToPtr(params->equation) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetClipPlanexOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum plane;
        PTR32 equation;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetClipPlanexOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetClipPlanexOES( params->plane, ULongToPtr(params->equation) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetColorTable( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum format;
        GLenum type;
        PTR32 table;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetColorTable) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTable( params->target, params->format, params->type, ULongToPtr(params->table) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetColorTableEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum format;
        GLenum type;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetColorTableEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTableEXT( params->target, params->format, params->type, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetColorTableParameterfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetColorTableParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTableParameterfv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetColorTableParameterfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetColorTableParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTableParameterfvEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetColorTableParameterfvSGI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetColorTableParameterfvSGI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTableParameterfvSGI( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetColorTableParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetColorTableParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTableParameteriv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetColorTableParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetColorTableParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTableParameterivEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetColorTableParameterivSGI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetColorTableParameterivSGI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTableParameterivSGI( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetColorTableSGI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum format;
        GLenum type;
        PTR32 table;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetColorTableSGI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetColorTableSGI( params->target, params->format, params->type, ULongToPtr(params->table) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetCombinerInputParameterfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stage;
        GLenum portion;
        GLenum variable;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetCombinerInputParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCombinerInputParameterfvNV( params->stage, params->portion, params->variable, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetCombinerInputParameterivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stage;
        GLenum portion;
        GLenum variable;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetCombinerInputParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCombinerInputParameterivNV( params->stage, params->portion, params->variable, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetCombinerOutputParameterfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stage;
        GLenum portion;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetCombinerOutputParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCombinerOutputParameterfvNV( params->stage, params->portion, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetCombinerOutputParameterivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stage;
        GLenum portion;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetCombinerOutputParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCombinerOutputParameterivNV( params->stage, params->portion, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetCombinerStageParameterfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stage;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetCombinerStageParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCombinerStageParameterfvNV( params->stage, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetCommandHeaderNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum tokenID;
        GLuint size;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetCommandHeaderNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetCommandHeaderNV( params->tokenID, params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetCompressedMultiTexImageEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint lod;
        PTR32 img;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetCompressedMultiTexImageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCompressedMultiTexImageEXT( params->texunit, params->target, params->lod, ULongToPtr(params->img) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetCompressedTexImage( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        PTR32 img;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetCompressedTexImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCompressedTexImage( params->target, params->level, ULongToPtr(params->img) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetCompressedTexImageARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        PTR32 img;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetCompressedTexImageARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCompressedTexImageARB( params->target, params->level, ULongToPtr(params->img) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetCompressedTextureImage( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLsizei bufSize;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetCompressedTextureImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCompressedTextureImage( params->texture, params->level, params->bufSize, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetCompressedTextureImageEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint lod;
        PTR32 img;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetCompressedTextureImageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCompressedTextureImageEXT( params->texture, params->target, params->lod, ULongToPtr(params->img) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetCompressedTextureSubImage( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLsizei bufSize;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetCompressedTextureSubImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCompressedTextureSubImage( params->texture, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->bufSize, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetConvolutionFilter( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum format;
        GLenum type;
        PTR32 image;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetConvolutionFilter) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetConvolutionFilter( params->target, params->format, params->type, ULongToPtr(params->image) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetConvolutionFilterEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum format;
        GLenum type;
        PTR32 image;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetConvolutionFilterEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetConvolutionFilterEXT( params->target, params->format, params->type, ULongToPtr(params->image) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetConvolutionParameterfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetConvolutionParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetConvolutionParameterfv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetConvolutionParameterfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetConvolutionParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetConvolutionParameterfvEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetConvolutionParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetConvolutionParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetConvolutionParameteriv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetConvolutionParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetConvolutionParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetConvolutionParameterivEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetConvolutionParameterxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetConvolutionParameterxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetConvolutionParameterxvOES( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetCoverageModulationTableNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei bufSize;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetCoverageModulationTableNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetCoverageModulationTableNV( params->bufSize, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetDebugMessageLog( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint count;
        GLsizei bufSize;
        PTR32 sources;
        PTR32 types;
        PTR32 ids;
        PTR32 severities;
        PTR32 lengths;
        PTR32 messageLog;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetDebugMessageLog) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetDebugMessageLog( params->count, params->bufSize, ULongToPtr(params->sources), ULongToPtr(params->types), ULongToPtr(params->ids), ULongToPtr(params->severities), ULongToPtr(params->lengths), ULongToPtr(params->messageLog) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetDebugMessageLogAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint count;
        GLsizei bufSize;
        PTR32 categories;
        PTR32 severities;
        PTR32 ids;
        PTR32 lengths;
        PTR32 message;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetDebugMessageLogAMD) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetDebugMessageLogAMD( params->count, params->bufSize, ULongToPtr(params->categories), ULongToPtr(params->severities), ULongToPtr(params->ids), ULongToPtr(params->lengths), ULongToPtr(params->message) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetDebugMessageLogARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint count;
        GLsizei bufSize;
        PTR32 sources;
        PTR32 types;
        PTR32 ids;
        PTR32 severities;
        PTR32 lengths;
        PTR32 messageLog;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetDebugMessageLogARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetDebugMessageLogARB( params->count, params->bufSize, ULongToPtr(params->sources), ULongToPtr(params->types), ULongToPtr(params->ids), ULongToPtr(params->severities), ULongToPtr(params->lengths), ULongToPtr(params->messageLog) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetDetailTexFuncSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetDetailTexFuncSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetDetailTexFuncSGIS( params->target, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetDoubleIndexedvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetDoubleIndexedvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetDoubleIndexedvEXT( params->target, params->index, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetDoublei_v( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetDoublei_v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetDoublei_v( params->target, params->index, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetDoublei_vEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetDoublei_vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetDoublei_vEXT( params->pname, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFenceivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint fence;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFenceivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFenceivNV( params->fence, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFinalCombinerInputParameterfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum variable;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFinalCombinerInputParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFinalCombinerInputParameterfvNV( params->variable, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFinalCombinerInputParameterivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum variable;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFinalCombinerInputParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFinalCombinerInputParameterivNV( params->variable, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFirstPerfQueryIdINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 queryId;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFirstPerfQueryIdINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFirstPerfQueryIdINTEL( ULongToPtr(params->queryId) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFixedv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFixedv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFixedv( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFixedvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFixedvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFixedvOES( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFloatIndexedvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFloatIndexedvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFloatIndexedvEXT( params->target, params->index, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFloati_v( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFloati_v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFloati_v( params->target, params->index, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFloati_vEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFloati_vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFloati_vEXT( params->pname, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFogFuncSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFogFuncSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFogFuncSGIS( ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFragDataIndex( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        PTR32 name;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFragDataIndex) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetFragDataIndex( params->program, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFragDataLocation( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        PTR32 name;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFragDataLocation) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetFragDataLocation( params->program, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFragDataLocationEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        PTR32 name;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFragDataLocationEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetFragDataLocationEXT( params->program, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFragmentLightfvSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFragmentLightfvSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFragmentLightfvSGIX( params->light, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFragmentLightivSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFragmentLightivSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFragmentLightivSGIX( params->light, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFragmentMaterialfvSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFragmentMaterialfvSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFragmentMaterialfvSGIX( params->face, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFragmentMaterialivSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFragmentMaterialivSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFragmentMaterialivSGIX( params->face, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFragmentShadingRatesEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei samples;
        GLsizei maxCount;
        PTR32 count;
        PTR32 shadingRates;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFragmentShadingRatesEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFragmentShadingRatesEXT( params->samples, params->maxCount, ULongToPtr(params->count), ULongToPtr(params->shadingRates) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFramebufferAttachmentParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFramebufferAttachmentParameteriv) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glGetFramebufferAttachmentParameteriv( params->target, params->attachment, params->pname, ULongToPtr(params->params) );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFramebufferAttachmentParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum attachment;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFramebufferAttachmentParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    push_default_fbo( teb );
    funcs->p_glGetFramebufferAttachmentParameterivEXT( params->target, params->attachment, params->pname, ULongToPtr(params->params) );
    pop_default_fbo( teb );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFramebufferParameterfvAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLuint numsamples;
        GLuint pixelindex;
        GLsizei size;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFramebufferParameterfvAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetFramebufferParameterfvAMD( params->target, params->pname, params->numsamples, params->pixelindex, params->size, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFramebufferParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFramebufferParameteriv) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetFramebufferParameteriv( teb, params->target, params->pname, ULongToPtr(params->params), funcs->p_glGetFramebufferParameteriv );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFramebufferParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFramebufferParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetFramebufferParameterivEXT( teb, params->framebuffer, params->pname, ULongToPtr(params->params), funcs->p_glGetFramebufferParameterivEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetFramebufferParameterivMESA( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetFramebufferParameterivMESA) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetFramebufferParameteriv( teb, params->target, params->pname, ULongToPtr(params->params), funcs->p_glGetFramebufferParameterivMESA );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetGraphicsResetStatus( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetGraphicsResetStatus) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetGraphicsResetStatus();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetGraphicsResetStatusARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetGraphicsResetStatusARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetGraphicsResetStatusARB();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetHandleARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLhandleARB ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetHandleARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetHandleARB( params->pname );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetHistogram( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLboolean reset;
        GLenum format;
        GLenum type;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetHistogram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetHistogram( params->target, params->reset, params->format, params->type, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetHistogramEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLboolean reset;
        GLenum format;
        GLenum type;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetHistogramEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetHistogramEXT( params->target, params->reset, params->format, params->type, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetHistogramParameterfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetHistogramParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetHistogramParameterfv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetHistogramParameterfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetHistogramParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetHistogramParameterfvEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetHistogramParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetHistogramParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetHistogramParameteriv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetHistogramParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetHistogramParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetHistogramParameterivEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetHistogramParameterxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetHistogramParameterxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetHistogramParameterxvOES( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetImageHandleARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLboolean layered;
        GLint layer;
        GLenum format;
        GLuint64 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetImageHandleARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetImageHandleARB( params->texture, params->level, params->layered, params->layer, params->format );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetImageHandleNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLboolean layered;
        GLint layer;
        GLenum format;
        GLuint64 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetImageHandleNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetImageHandleNV( params->texture, params->level, params->layered, params->layer, params->format );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetImageTransformParameterfvHP( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetImageTransformParameterfvHP) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetImageTransformParameterfvHP( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetImageTransformParameterivHP( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetImageTransformParameterivHP) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetImageTransformParameterivHP( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetInfoLogARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB obj;
        GLsizei maxLength;
        PTR32 length;
        PTR32 infoLog;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetInfoLogARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetInfoLogARB( params->obj, params->maxLength, ULongToPtr(params->length), ULongToPtr(params->infoLog) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetInstrumentsSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetInstrumentsSGIX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetInstrumentsSGIX();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetInteger64i_v( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetInteger64i_v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetInteger64i_v( params->target, params->index, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetInteger64v( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetInteger64v) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetInteger64v( teb, params->pname, ULongToPtr(params->data), funcs->p_glGetInteger64v );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetIntegerIndexedvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetIntegerIndexedvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetIntegerIndexedvEXT( params->target, params->index, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetIntegeri_v( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetIntegeri_v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetIntegeri_v( params->target, params->index, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetIntegerui64i_vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum value;
        GLuint index;
        PTR32 result;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetIntegerui64i_vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetIntegerui64i_vNV( params->value, params->index, ULongToPtr(params->result) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetIntegerui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum value;
        PTR32 result;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetIntegerui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetIntegerui64vNV( params->value, ULongToPtr(params->result) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetInternalformatSampleivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLsizei samples;
        GLenum pname;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetInternalformatSampleivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetInternalformatSampleivNV( params->target, params->internalformat, params->samples, params->pname, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetInternalformati64v( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLenum pname;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetInternalformati64v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetInternalformati64v( params->target, params->internalformat, params->pname, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetInternalformativ( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLenum pname;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetInternalformativ) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetInternalformativ( params->target, params->internalformat, params->pname, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetInvariantBooleanvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum value;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetInvariantBooleanvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetInvariantBooleanvEXT( params->id, params->value, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetInvariantFloatvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum value;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetInvariantFloatvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetInvariantFloatvEXT( params->id, params->value, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetInvariantIntegervEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum value;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetInvariantIntegervEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetInvariantIntegervEXT( params->id, params->value, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetLightxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetLightxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetLightxOES( params->light, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetLightxv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetLightxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetLightxv( params->light, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetListParameterfvSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint list;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetListParameterfvSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetListParameterfvSGIX( params->list, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetListParameterivSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint list;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetListParameterivSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetListParameterivSGIX( params->list, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetLocalConstantBooleanvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum value;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetLocalConstantBooleanvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetLocalConstantBooleanvEXT( params->id, params->value, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetLocalConstantFloatvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum value;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetLocalConstantFloatvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetLocalConstantFloatvEXT( params->id, params->value, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetLocalConstantIntegervEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum value;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetLocalConstantIntegervEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetLocalConstantIntegervEXT( params->id, params->value, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMapAttribParameterfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMapAttribParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapAttribParameterfvNV( params->target, params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMapAttribParameterivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMapAttribParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapAttribParameterivNV( params->target, params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMapControlPointsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLenum type;
        GLsizei ustride;
        GLsizei vstride;
        GLboolean packed;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMapControlPointsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapControlPointsNV( params->target, params->index, params->type, params->ustride, params->vstride, params->packed, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMapParameterfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMapParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapParameterfvNV( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMapParameterivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMapParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapParameterivNV( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMapxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum query;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMapxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMapxvOES( params->target, params->query, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMaterialxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMaterialxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMaterialxOES( params->face, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMaterialxv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMaterialxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMaterialxv( params->face, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMemoryObjectDetachedResourcesuivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint memory;
        GLenum pname;
        GLint first;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMemoryObjectDetachedResourcesuivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMemoryObjectDetachedResourcesuivNV( params->memory, params->pname, params->first, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMemoryObjectParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint memoryObject;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMemoryObjectParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMemoryObjectParameterivEXT( params->memoryObject, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMinmax( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLboolean reset;
        GLenum format;
        GLenum type;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMinmax) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMinmax( params->target, params->reset, params->format, params->type, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMinmaxEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLboolean reset;
        GLenum format;
        GLenum type;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMinmaxEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMinmaxEXT( params->target, params->reset, params->format, params->type, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMinmaxParameterfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMinmaxParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMinmaxParameterfv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMinmaxParameterfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMinmaxParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMinmaxParameterfvEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMinmaxParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMinmaxParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMinmaxParameteriv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMinmaxParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMinmaxParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMinmaxParameterivEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMultiTexEnvfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMultiTexEnvfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexEnvfvEXT( params->texunit, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMultiTexEnvivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMultiTexEnvivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexEnvivEXT( params->texunit, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMultiTexGendvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum coord;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMultiTexGendvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexGendvEXT( params->texunit, params->coord, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMultiTexGenfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum coord;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMultiTexGenfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexGenfvEXT( params->texunit, params->coord, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMultiTexGenivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum coord;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMultiTexGenivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexGenivEXT( params->texunit, params->coord, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMultiTexImageEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMultiTexImageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexImageEXT( params->texunit, params->target, params->level, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMultiTexLevelParameterfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMultiTexLevelParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexLevelParameterfvEXT( params->texunit, params->target, params->level, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMultiTexLevelParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMultiTexLevelParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexLevelParameterivEXT( params->texunit, params->target, params->level, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMultiTexParameterIivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMultiTexParameterIivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexParameterIivEXT( params->texunit, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMultiTexParameterIuivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMultiTexParameterIuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexParameterIuivEXT( params->texunit, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMultiTexParameterfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMultiTexParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexParameterfvEXT( params->texunit, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMultiTexParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMultiTexParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultiTexParameterivEXT( params->texunit, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMultisamplefv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLuint index;
        PTR32 val;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMultisamplefv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultisamplefv( params->pname, params->index, ULongToPtr(params->val) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetMultisamplefvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLuint index;
        PTR32 val;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetMultisamplefvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetMultisamplefvNV( params->pname, params->index, ULongToPtr(params->val) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedBufferParameteri64v( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedBufferParameteri64v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedBufferParameteri64v( params->buffer, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedBufferParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedBufferParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedBufferParameteriv( params->buffer, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedBufferParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedBufferParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedBufferParameterivEXT( params->buffer, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedBufferParameterui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedBufferParameterui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedBufferParameterui64vNV( params->buffer, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedBufferPointerv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedBufferPointerv) return STATUS_NOT_IMPLEMENTED;
    wow64_glGetNamedBufferPointerv( teb, params->buffer, params->pname, ULongToPtr(params->params), funcs->p_glGetNamedBufferPointerv );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedBufferPointervEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedBufferPointervEXT) return STATUS_NOT_IMPLEMENTED;
    wow64_glGetNamedBufferPointerv( teb, params->buffer, params->pname, ULongToPtr(params->params), funcs->p_glGetNamedBufferPointervEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedBufferSubData( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 offset;
        PTR32 size;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedBufferSubData( params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedBufferSubDataEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 offset;
        PTR32 size;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedBufferSubDataEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedBufferSubDataEXT( params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedFramebufferAttachmentParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum attachment;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedFramebufferAttachmentParameteriv) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glGetNamedFramebufferAttachmentParameteriv( framebuffer, params->attachment, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedFramebufferAttachmentParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum attachment;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedFramebufferAttachmentParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glGetNamedFramebufferAttachmentParameterivEXT( framebuffer, params->attachment, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedFramebufferParameterfvAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum pname;
        GLuint numsamples;
        GLuint pixelindex;
        GLsizei size;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedFramebufferParameterfvAMD) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glGetNamedFramebufferParameterfvAMD( framebuffer, params->pname, params->numsamples, params->pixelindex, params->size, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedFramebufferParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedFramebufferParameteriv) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glGetNamedFramebufferParameteriv( framebuffer, params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedFramebufferParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedFramebufferParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glGetNamedFramebufferParameterivEXT( framebuffer, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedProgramLocalParameterIivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedProgramLocalParameterIivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedProgramLocalParameterIivEXT( params->program, params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedProgramLocalParameterIuivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedProgramLocalParameterIuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedProgramLocalParameterIuivEXT( params->program, params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedProgramLocalParameterdvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedProgramLocalParameterdvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedProgramLocalParameterdvEXT( params->program, params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedProgramLocalParameterfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedProgramLocalParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedProgramLocalParameterfvEXT( params->program, params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedProgramStringEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLenum pname;
        PTR32 string;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedProgramStringEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedProgramStringEXT( params->program, params->target, params->pname, ULongToPtr(params->string) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedProgramivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedProgramivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedProgramivEXT( params->program, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedRenderbufferParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint renderbuffer;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedRenderbufferParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedRenderbufferParameteriv( params->renderbuffer, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedRenderbufferParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint renderbuffer;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedRenderbufferParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedRenderbufferParameterivEXT( params->renderbuffer, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedStringARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint namelen;
        PTR32 name;
        GLsizei bufSize;
        PTR32 stringlen;
        PTR32 string;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedStringARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedStringARB( params->namelen, ULongToPtr(params->name), params->bufSize, ULongToPtr(params->stringlen), ULongToPtr(params->string) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNamedStringivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint namelen;
        PTR32 name;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNamedStringivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNamedStringivARB( params->namelen, ULongToPtr(params->name), params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetNextPerfQueryIdINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint queryId;
        PTR32 nextQueryId;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetNextPerfQueryIdINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetNextPerfQueryIdINTEL( params->queryId, ULongToPtr(params->nextQueryId) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetObjectBufferfvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetObjectBufferfvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetObjectBufferfvATI( params->buffer, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetObjectBufferivATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetObjectBufferivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetObjectBufferivATI( params->buffer, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetObjectLabel( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum identifier;
        GLuint name;
        GLsizei bufSize;
        PTR32 length;
        PTR32 label;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetObjectLabel) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetObjectLabel( params->identifier, params->name, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->label) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetObjectLabelEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLuint object;
        GLsizei bufSize;
        PTR32 length;
        PTR32 label;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetObjectLabelEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetObjectLabelEXT( params->type, params->object, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->label) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetObjectParameterfvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB obj;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetObjectParameterfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetObjectParameterfvARB( params->obj, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetObjectParameterivAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum objectType;
        GLuint name;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetObjectParameterivAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetObjectParameterivAPPLE( params->objectType, params->name, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetObjectParameterivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB obj;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetObjectParameterivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetObjectParameterivARB( params->obj, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetObjectPtrLabel( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 ptr;
        GLsizei bufSize;
        PTR32 length;
        PTR32 label;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetObjectPtrLabel) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetObjectPtrLabel( ULongToPtr(params->ptr), params->bufSize, ULongToPtr(params->length), ULongToPtr(params->label) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetOcclusionQueryivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetOcclusionQueryivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetOcclusionQueryivNV( params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetOcclusionQueryuivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetOcclusionQueryuivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetOcclusionQueryuivNV( params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPathColorGenfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum color;
        GLenum pname;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPathColorGenfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathColorGenfvNV( params->color, params->pname, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPathColorGenivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum color;
        GLenum pname;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPathColorGenivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathColorGenivNV( params->color, params->pname, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPathCommandsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        PTR32 commands;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPathCommandsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathCommandsNV( params->path, ULongToPtr(params->commands) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPathCoordsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPathCoordsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathCoordsNV( params->path, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPathDashArrayNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        PTR32 dashArray;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPathDashArrayNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathDashArrayNV( params->path, ULongToPtr(params->dashArray) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPathLengthNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLsizei startSegment;
        GLsizei numSegments;
        GLfloat ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPathLengthNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetPathLengthNV( params->path, params->startSegment, params->numSegments );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPathMetricRangeNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLbitfield metricQueryMask;
        GLuint firstPathName;
        GLsizei numPaths;
        GLsizei stride;
        PTR32 metrics;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPathMetricRangeNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathMetricRangeNV( params->metricQueryMask, params->firstPathName, params->numPaths, params->stride, ULongToPtr(params->metrics) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPathMetricsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLbitfield metricQueryMask;
        GLsizei numPaths;
        GLenum pathNameType;
        PTR32 paths;
        GLuint pathBase;
        GLsizei stride;
        PTR32 metrics;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPathMetricsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathMetricsNV( params->metricQueryMask, params->numPaths, params->pathNameType, ULongToPtr(params->paths), params->pathBase, params->stride, ULongToPtr(params->metrics) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPathParameterfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLenum pname;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPathParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathParameterfvNV( params->path, params->pname, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPathParameterivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLenum pname;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPathParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathParameterivNV( params->path, params->pname, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPathSpacingNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pathListMode;
        GLsizei numPaths;
        GLenum pathNameType;
        PTR32 paths;
        GLuint pathBase;
        GLfloat advanceScale;
        GLfloat kerningScale;
        GLenum transformType;
        PTR32 returnedSpacing;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPathSpacingNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathSpacingNV( params->pathListMode, params->numPaths, params->pathNameType, ULongToPtr(params->paths), params->pathBase, params->advanceScale, params->kerningScale, params->transformType, ULongToPtr(params->returnedSpacing) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPathTexGenfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texCoordSet;
        GLenum pname;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPathTexGenfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathTexGenfvNV( params->texCoordSet, params->pname, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPathTexGenivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texCoordSet;
        GLenum pname;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPathTexGenivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPathTexGenivNV( params->texCoordSet, params->pname, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPerfCounterInfoINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint queryId;
        GLuint counterId;
        GLuint counterNameLength;
        PTR32 counterName;
        GLuint counterDescLength;
        PTR32 counterDesc;
        PTR32 counterOffset;
        PTR32 counterDataSize;
        PTR32 counterTypeEnum;
        PTR32 counterDataTypeEnum;
        PTR32 rawCounterMaxValue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPerfCounterInfoINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfCounterInfoINTEL( params->queryId, params->counterId, params->counterNameLength, ULongToPtr(params->counterName), params->counterDescLength, ULongToPtr(params->counterDesc), ULongToPtr(params->counterOffset), ULongToPtr(params->counterDataSize), ULongToPtr(params->counterTypeEnum), ULongToPtr(params->counterDataTypeEnum), ULongToPtr(params->rawCounterMaxValue) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPerfMonitorCounterDataAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint monitor;
        GLenum pname;
        GLsizei dataSize;
        PTR32 data;
        PTR32 bytesWritten;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPerfMonitorCounterDataAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfMonitorCounterDataAMD( params->monitor, params->pname, params->dataSize, ULongToPtr(params->data), ULongToPtr(params->bytesWritten) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPerfMonitorCounterInfoAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint group;
        GLuint counter;
        GLenum pname;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPerfMonitorCounterInfoAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfMonitorCounterInfoAMD( params->group, params->counter, params->pname, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPerfMonitorCounterStringAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint group;
        GLuint counter;
        GLsizei bufSize;
        PTR32 length;
        PTR32 counterString;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPerfMonitorCounterStringAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfMonitorCounterStringAMD( params->group, params->counter, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->counterString) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPerfMonitorCountersAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint group;
        PTR32 numCounters;
        PTR32 maxActiveCounters;
        GLsizei counterSize;
        PTR32 counters;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPerfMonitorCountersAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfMonitorCountersAMD( params->group, ULongToPtr(params->numCounters), ULongToPtr(params->maxActiveCounters), params->counterSize, ULongToPtr(params->counters) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPerfMonitorGroupStringAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint group;
        GLsizei bufSize;
        PTR32 length;
        PTR32 groupString;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPerfMonitorGroupStringAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfMonitorGroupStringAMD( params->group, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->groupString) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPerfMonitorGroupsAMD( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 numGroups;
        GLsizei groupsSize;
        PTR32 groups;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPerfMonitorGroupsAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfMonitorGroupsAMD( ULongToPtr(params->numGroups), params->groupsSize, ULongToPtr(params->groups) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPerfQueryDataINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint queryHandle;
        GLuint flags;
        GLsizei dataSize;
        PTR32 data;
        PTR32 bytesWritten;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPerfQueryDataINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfQueryDataINTEL( params->queryHandle, params->flags, params->dataSize, ULongToPtr(params->data), ULongToPtr(params->bytesWritten) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPerfQueryIdByNameINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 queryName;
        PTR32 queryId;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPerfQueryIdByNameINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfQueryIdByNameINTEL( ULongToPtr(params->queryName), ULongToPtr(params->queryId) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPerfQueryInfoINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint queryId;
        GLuint queryNameLength;
        PTR32 queryName;
        PTR32 dataSize;
        PTR32 noCounters;
        PTR32 noInstances;
        PTR32 capsMask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPerfQueryInfoINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPerfQueryInfoINTEL( params->queryId, params->queryNameLength, ULongToPtr(params->queryName), ULongToPtr(params->dataSize), ULongToPtr(params->noCounters), ULongToPtr(params->noInstances), ULongToPtr(params->capsMask) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPixelMapxv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum map;
        GLint size;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPixelMapxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPixelMapxv( params->map, params->size, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPixelTexGenParameterfvSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPixelTexGenParameterfvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPixelTexGenParameterfvSGIS( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPixelTexGenParameterivSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPixelTexGenParameterivSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPixelTexGenParameterivSGIS( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPixelTransformParameterfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPixelTransformParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPixelTransformParameterfvEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPixelTransformParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPixelTransformParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPixelTransformParameterivEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetPointerIndexedvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 data;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glGetPointeri_vEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLuint index;
        PTR32 params;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glGetPointervEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    void *params_arg;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetPointervEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetPointervEXT( params->pname, &params_arg );
    *(PTR32 *)UlongToPtr(params->params) = PtrToUlong( params_arg );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramBinary( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLsizei bufSize;
        PTR32 length;
        PTR32 binaryFormat;
        PTR32 binary;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramBinary) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramBinary( params->program, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->binaryFormat), ULongToPtr(params->binary) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramEnvParameterIivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramEnvParameterIivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramEnvParameterIivNV( params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramEnvParameterIuivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramEnvParameterIuivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramEnvParameterIuivNV( params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramEnvParameterdvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramEnvParameterdvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramEnvParameterdvARB( params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramEnvParameterfvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramEnvParameterfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramEnvParameterfvARB( params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramInfoLog( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLsizei bufSize;
        PTR32 length;
        PTR32 infoLog;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramInfoLog) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramInfoLog( params->program, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->infoLog) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramInterfaceiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum programInterface;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramInterfaceiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramInterfaceiv( params->program, params->programInterface, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramLocalParameterIivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramLocalParameterIivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramLocalParameterIivNV( params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramLocalParameterIuivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramLocalParameterIuivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramLocalParameterIuivNV( params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramLocalParameterdvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramLocalParameterdvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramLocalParameterdvARB( params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramLocalParameterfvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramLocalParameterfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramLocalParameterfvARB( params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramNamedParameterdvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLsizei len;
        PTR32 name;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramNamedParameterdvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramNamedParameterdvNV( params->id, params->len, ULongToPtr(params->name), ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramNamedParameterfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLsizei len;
        PTR32 name;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramNamedParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramNamedParameterfvNV( params->id, params->len, ULongToPtr(params->name), ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramParameterdvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramParameterdvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramParameterdvNV( params->target, params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramParameterfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramParameterfvNV( params->target, params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramPipelineInfoLog( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint pipeline;
        GLsizei bufSize;
        PTR32 length;
        PTR32 infoLog;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramPipelineInfoLog) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramPipelineInfoLog( params->pipeline, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->infoLog) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramPipelineiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint pipeline;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramPipelineiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramPipelineiv( params->pipeline, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramResourceIndex( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum programInterface;
        PTR32 name;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramResourceIndex) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetProgramResourceIndex( params->program, params->programInterface, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramResourceLocation( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum programInterface;
        PTR32 name;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramResourceLocation) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetProgramResourceLocation( params->program, params->programInterface, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramResourceLocationIndex( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum programInterface;
        PTR32 name;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramResourceLocationIndex) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetProgramResourceLocationIndex( params->program, params->programInterface, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramResourceName( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum programInterface;
        GLuint index;
        GLsizei bufSize;
        PTR32 length;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramResourceName) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramResourceName( params->program, params->programInterface, params->index, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramResourcefvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum programInterface;
        GLuint index;
        GLsizei propCount;
        PTR32 props;
        GLsizei count;
        PTR32 length;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramResourcefvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramResourcefvNV( params->program, params->programInterface, params->index, params->propCount, ULongToPtr(params->props), params->count, ULongToPtr(params->length), ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramResourceiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum programInterface;
        GLuint index;
        GLsizei propCount;
        PTR32 props;
        GLsizei count;
        PTR32 length;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramResourceiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramResourceiv( params->program, params->programInterface, params->index, params->propCount, ULongToPtr(params->props), params->count, ULongToPtr(params->length), ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramStageiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum shadertype;
        GLenum pname;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramStageiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramStageiv( params->program, params->shadertype, params->pname, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramStringARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 string;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramStringARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramStringARB( params->target, params->pname, ULongToPtr(params->string) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramStringNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum pname;
        PTR32 program;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramStringNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramStringNV( params->id, params->pname, ULongToPtr(params->program) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramSubroutineParameteruivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramSubroutineParameteruivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramSubroutineParameteruivNV( params->target, params->index, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramiv( params->program, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramivARB( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetProgramivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetProgramivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetProgramivNV( params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetQueryBufferObjecti64v( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLuint buffer;
        GLenum pname;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetQueryBufferObjecti64v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryBufferObjecti64v( params->id, params->buffer, params->pname, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetQueryBufferObjectiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLuint buffer;
        GLenum pname;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetQueryBufferObjectiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryBufferObjectiv( params->id, params->buffer, params->pname, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetQueryBufferObjectui64v( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLuint buffer;
        GLenum pname;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetQueryBufferObjectui64v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryBufferObjectui64v( params->id, params->buffer, params->pname, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetQueryBufferObjectuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLuint buffer;
        GLenum pname;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetQueryBufferObjectuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryBufferObjectuiv( params->id, params->buffer, params->pname, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetQueryIndexediv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetQueryIndexediv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryIndexediv( params->target, params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetQueryObjecti64v( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetQueryObjecti64v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryObjecti64v( params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetQueryObjecti64vEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetQueryObjecti64vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryObjecti64vEXT( params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetQueryObjectiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetQueryObjectiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryObjectiv( params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetQueryObjectivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetQueryObjectivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryObjectivARB( params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetQueryObjectui64v( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetQueryObjectui64v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryObjectui64v( params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetQueryObjectui64vEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetQueryObjectui64vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryObjectui64vEXT( params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetQueryObjectuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetQueryObjectuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryObjectuiv( params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetQueryObjectuivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetQueryObjectuivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryObjectuivARB( params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetQueryiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetQueryiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryiv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetQueryivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetQueryivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetQueryivARB( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetRenderbufferParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetRenderbufferParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetRenderbufferParameteriv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetRenderbufferParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetRenderbufferParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetRenderbufferParameterivEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetSamplerParameterIiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint sampler;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetSamplerParameterIiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSamplerParameterIiv( params->sampler, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetSamplerParameterIuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint sampler;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetSamplerParameterIuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSamplerParameterIuiv( params->sampler, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetSamplerParameterfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint sampler;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetSamplerParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSamplerParameterfv( params->sampler, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetSamplerParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint sampler;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetSamplerParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSamplerParameteriv( params->sampler, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetSemaphoreParameterivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint semaphore;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetSemaphoreParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSemaphoreParameterivNV( params->semaphore, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetSemaphoreParameterui64vEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint semaphore;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetSemaphoreParameterui64vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSemaphoreParameterui64vEXT( params->semaphore, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetSeparableFilter( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum format;
        GLenum type;
        PTR32 row;
        PTR32 column;
        PTR32 span;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetSeparableFilter) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSeparableFilter( params->target, params->format, params->type, ULongToPtr(params->row), ULongToPtr(params->column), ULongToPtr(params->span) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetSeparableFilterEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum format;
        GLenum type;
        PTR32 row;
        PTR32 column;
        PTR32 span;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetSeparableFilterEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSeparableFilterEXT( params->target, params->format, params->type, ULongToPtr(params->row), ULongToPtr(params->column), ULongToPtr(params->span) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetShaderInfoLog( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint shader;
        GLsizei bufSize;
        PTR32 length;
        PTR32 infoLog;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetShaderInfoLog) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetShaderInfoLog( params->shader, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->infoLog) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetShaderPrecisionFormat( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum shadertype;
        GLenum precisiontype;
        PTR32 range;
        PTR32 precision;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetShaderPrecisionFormat) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetShaderPrecisionFormat( params->shadertype, params->precisiontype, ULongToPtr(params->range), ULongToPtr(params->precision) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetShaderSource( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint shader;
        GLsizei bufSize;
        PTR32 length;
        PTR32 source;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetShaderSource) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetShaderSource( params->shader, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->source) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetShaderSourceARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB obj;
        GLsizei maxLength;
        PTR32 length;
        PTR32 source;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetShaderSourceARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetShaderSourceARB( params->obj, params->maxLength, ULongToPtr(params->length), ULongToPtr(params->source) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetShaderiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint shader;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetShaderiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetShaderiv( params->shader, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetShadingRateImagePaletteNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint viewport;
        GLuint entry;
        PTR32 rate;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetShadingRateImagePaletteNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetShadingRateImagePaletteNV( params->viewport, params->entry, ULongToPtr(params->rate) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetShadingRateSampleLocationivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum rate;
        GLuint samples;
        GLuint index;
        PTR32 location;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetShadingRateSampleLocationivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetShadingRateSampleLocationivNV( params->rate, params->samples, params->index, ULongToPtr(params->location) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetSharpenTexFuncSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetSharpenTexFuncSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSharpenTexFuncSGIS( params->target, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetStageIndexNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum shadertype;
        GLushort ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetStageIndexNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetStageIndexNV( params->shadertype );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetStringi( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum name;
        GLuint index;
        PTR32 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const GLubyte *ret;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetStringi) return STATUS_NOT_IMPLEMENTED;
    ret = funcs->p_glGetStringi( params->name, params->index );
    return return_wow64_string( ret, &params->ret );
}

static NTSTATUS wow64_ext_glGetSubroutineIndex( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum shadertype;
        PTR32 name;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetSubroutineIndex) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetSubroutineIndex( params->program, params->shadertype, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetSubroutineUniformLocation( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum shadertype;
        PTR32 name;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetSubroutineUniformLocation) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetSubroutineUniformLocation( params->program, params->shadertype, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetSynciv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 sync;
        GLenum pname;
        GLsizei count;
        PTR32 length;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetSynciv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetSynciv( get_unix_sync( ULongToPtr(params->sync) ), params->pname, params->count, ULongToPtr(params->length), ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTexBumpParameterfvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexBumpParameterfvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexBumpParameterfvATI( params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTexBumpParameterivATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexBumpParameterivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexBumpParameterivATI( params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTexEnvxv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexEnvxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexEnvxv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTexEnvxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexEnvxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexEnvxvOES( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTexFilterFuncSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum filter;
        PTR32 weights;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexFilterFuncSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexFilterFuncSGIS( params->target, params->filter, ULongToPtr(params->weights) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTexGenxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum coord;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexGenxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexGenxvOES( params->coord, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTexLevelParameterxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexLevelParameterxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexLevelParameterxvOES( params->target, params->level, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTexParameterIiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexParameterIiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameterIiv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTexParameterIivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexParameterIivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameterIivEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTexParameterIuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexParameterIuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameterIuiv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTexParameterIuivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexParameterIuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameterIuivEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTexParameterPointervAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glGetTexParameterxv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexParameterxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameterxv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTexParameterxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTexParameterxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTexParameterxvOES( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureHandleARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLuint64 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureHandleARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetTextureHandleARB( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureHandleNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLuint64 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureHandleNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetTextureHandleNV( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureImage( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLenum format;
        GLenum type;
        GLsizei bufSize;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureImage( params->texture, params->level, params->format, params->type, params->bufSize, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureImageEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureImageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureImageEXT( params->texture, params->target, params->level, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureLevelParameterfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureLevelParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureLevelParameterfv( params->texture, params->level, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureLevelParameterfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureLevelParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureLevelParameterfvEXT( params->texture, params->target, params->level, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureLevelParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureLevelParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureLevelParameteriv( params->texture, params->level, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureLevelParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureLevelParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureLevelParameterivEXT( params->texture, params->target, params->level, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureParameterIiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureParameterIiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureParameterIiv( params->texture, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureParameterIivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureParameterIivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureParameterIivEXT( params->texture, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureParameterIuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureParameterIuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureParameterIuiv( params->texture, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureParameterIuivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureParameterIuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureParameterIuivEXT( params->texture, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureParameterfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureParameterfv( params->texture, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureParameterfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureParameterfvEXT( params->texture, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureParameteriv( params->texture, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureParameterivEXT( params->texture, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureSamplerHandleARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLuint sampler;
        GLuint64 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureSamplerHandleARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetTextureSamplerHandleARB( params->texture, params->sampler );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureSamplerHandleNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLuint sampler;
        GLuint64 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureSamplerHandleNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetTextureSamplerHandleNV( params->texture, params->sampler );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTextureSubImage( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLenum format;
        GLenum type;
        GLsizei bufSize;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTextureSubImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTextureSubImage( params->texture, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->type, params->bufSize, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTrackMatrixivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint address;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTrackMatrixivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTrackMatrixivNV( params->target, params->address, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTransformFeedbackVarying( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint index;
        GLsizei bufSize;
        PTR32 length;
        PTR32 size;
        PTR32 type;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTransformFeedbackVarying) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTransformFeedbackVarying( params->program, params->index, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->size), ULongToPtr(params->type), ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTransformFeedbackVaryingEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint index;
        GLsizei bufSize;
        PTR32 length;
        PTR32 size;
        PTR32 type;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTransformFeedbackVaryingEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTransformFeedbackVaryingEXT( params->program, params->index, params->bufSize, ULongToPtr(params->length), ULongToPtr(params->size), ULongToPtr(params->type), ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTransformFeedbackVaryingNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint index;
        PTR32 location;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTransformFeedbackVaryingNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTransformFeedbackVaryingNV( params->program, params->index, ULongToPtr(params->location) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTransformFeedbacki64_v( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint xfb;
        GLenum pname;
        GLuint index;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTransformFeedbacki64_v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTransformFeedbacki64_v( params->xfb, params->pname, params->index, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTransformFeedbacki_v( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint xfb;
        GLenum pname;
        GLuint index;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTransformFeedbacki_v) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTransformFeedbacki_v( params->xfb, params->pname, params->index, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetTransformFeedbackiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint xfb;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetTransformFeedbackiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetTransformFeedbackiv( params->xfb, params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformBlockIndex( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        PTR32 uniformBlockName;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformBlockIndex) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetUniformBlockIndex( params->program, ULongToPtr(params->uniformBlockName) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformBufferSizeEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformBufferSizeEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetUniformBufferSizeEXT( params->program, params->location );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformIndices( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLsizei uniformCount;
        PTR32 uniformNames;
        PTR32 uniformIndices;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const GLchar **uniformNames;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformIndices) return STATUS_NOT_IMPLEMENTED;
    uniformNames = copy_wow64_ptr32s( params->uniformNames, params->uniformCount );
    funcs->p_glGetUniformIndices( params->program, params->uniformCount, uniformNames, ULongToPtr(params->uniformIndices) );
    free( uniformNames );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformLocation( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        PTR32 name;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformLocation) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetUniformLocation( params->program, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformLocationARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB programObj;
        PTR32 name;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformLocationARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetUniformLocationARB( params->programObj, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformOffsetEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        PTR32 ret;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glGetUniformSubroutineuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum shadertype;
        GLint location;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformSubroutineuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformSubroutineuiv( params->shadertype, params->location, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformdv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformdv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformdv( params->program, params->location, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformfv( params->program, params->location, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformfvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB programObj;
        GLint location;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformfvARB( params->programObj, params->location, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformi64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformi64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformi64vARB( params->program, params->location, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformi64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformi64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformi64vNV( params->program, params->location, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformiv( params->program, params->location, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB programObj;
        GLint location;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformivARB( params->programObj, params->location, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformui64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformui64vARB( params->program, params->location, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformui64vNV( params->program, params->location, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformuiv( params->program, params->location, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUniformuivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUniformuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUniformuivEXT( params->program, params->location, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUnsignedBytei_vEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUnsignedBytei_vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetUnsignedBytei_vEXT( params->target, params->index, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetUnsignedBytevEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetUnsignedBytevEXT) return STATUS_NOT_IMPLEMENTED;
    wrap_glGetUnsignedBytevEXT( teb, params->pname, ULongToPtr(params->data), funcs->p_glGetUnsignedBytevEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVariantArrayObjectfvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVariantArrayObjectfvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVariantArrayObjectfvATI( params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVariantArrayObjectivATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVariantArrayObjectivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVariantArrayObjectivATI( params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVariantBooleanvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum value;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVariantBooleanvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVariantBooleanvEXT( params->id, params->value, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVariantFloatvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum value;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVariantFloatvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVariantFloatvEXT( params->id, params->value, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVariantIntegervEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum value;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVariantIntegervEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVariantIntegervEXT( params->id, params->value, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVariantPointervEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum value;
        PTR32 data;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glGetVaryingLocationNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        PTR32 name;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVaryingLocationNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glGetVaryingLocationNV( params->program, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexArrayIndexed64iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint index;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexArrayIndexed64iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexArrayIndexed64iv( params->vaobj, params->index, params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexArrayIndexediv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint index;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexArrayIndexediv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexArrayIndexediv( params->vaobj, params->index, params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexArrayIntegeri_vEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint index;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexArrayIntegeri_vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexArrayIntegeri_vEXT( params->vaobj, params->index, params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexArrayIntegervEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexArrayIntegervEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexArrayIntegervEXT( params->vaobj, params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexArrayPointeri_vEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint index;
        GLenum pname;
        PTR32 param;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glGetVertexArrayPointervEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLenum pname;
        PTR32 param;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glGetVertexArrayiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexArrayiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexArrayiv( params->vaobj, params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribArrayObjectfvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribArrayObjectfvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribArrayObjectfvATI( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribArrayObjectivATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribArrayObjectivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribArrayObjectivATI( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribIiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribIiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribIiv( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribIivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribIivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribIivEXT( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribIuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribIuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribIuiv( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribIuivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribIuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribIuivEXT( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribLdv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribLdv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribLdv( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribLdvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribLdvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribLdvEXT( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribLi64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribLi64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribLi64vNV( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribLui64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribLui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribLui64vARB( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribLui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribLui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribLui64vNV( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribPointerv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    void *pointer_arg;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribPointerv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribPointerv( params->index, params->pname, &pointer_arg );
    *(PTR32 *)UlongToPtr(params->pointer) = PtrToUlong( pointer_arg );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribPointervARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    void *pointer_arg;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribPointervARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribPointervARB( params->index, params->pname, &pointer_arg );
    *(PTR32 *)UlongToPtr(params->pointer) = PtrToUlong( pointer_arg );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribPointervNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 pointer;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glGetVertexAttribdv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribdv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribdv( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribdvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribdvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribdvARB( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribdvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribdvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribdvNV( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribfv( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribfvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribfvARB( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribfvNV( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribiv( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribivARB( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVertexAttribivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVertexAttribivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVertexAttribivNV( params->index, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVideoCaptureStreamdvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_capture_slot;
        GLuint stream;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVideoCaptureStreamdvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVideoCaptureStreamdvNV( params->video_capture_slot, params->stream, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVideoCaptureStreamfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_capture_slot;
        GLuint stream;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVideoCaptureStreamfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVideoCaptureStreamfvNV( params->video_capture_slot, params->stream, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVideoCaptureStreamivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_capture_slot;
        GLuint stream;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVideoCaptureStreamivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVideoCaptureStreamivNV( params->video_capture_slot, params->stream, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVideoCaptureivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_capture_slot;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVideoCaptureivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVideoCaptureivNV( params->video_capture_slot, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVideoi64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_slot;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVideoi64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVideoi64vNV( params->video_slot, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVideoivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_slot;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVideoivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVideoivNV( params->video_slot, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVideoui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_slot;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVideoui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVideoui64vNV( params->video_slot, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVideouivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_slot;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetVideouivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetVideouivNV( params->video_slot, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetVkProcAddrNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 name;
        PTR32 ret;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glGetnColorTable( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum format;
        GLenum type;
        GLsizei bufSize;
        PTR32 table;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnColorTable) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnColorTable( params->target, params->format, params->type, params->bufSize, ULongToPtr(params->table) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnColorTableARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum format;
        GLenum type;
        GLsizei bufSize;
        PTR32 table;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnColorTableARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnColorTableARB( params->target, params->format, params->type, params->bufSize, ULongToPtr(params->table) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnCompressedTexImage( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint lod;
        GLsizei bufSize;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnCompressedTexImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnCompressedTexImage( params->target, params->lod, params->bufSize, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnCompressedTexImageARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint lod;
        GLsizei bufSize;
        PTR32 img;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnCompressedTexImageARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnCompressedTexImageARB( params->target, params->lod, params->bufSize, ULongToPtr(params->img) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnConvolutionFilter( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum format;
        GLenum type;
        GLsizei bufSize;
        PTR32 image;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnConvolutionFilter) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnConvolutionFilter( params->target, params->format, params->type, params->bufSize, ULongToPtr(params->image) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnConvolutionFilterARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum format;
        GLenum type;
        GLsizei bufSize;
        PTR32 image;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnConvolutionFilterARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnConvolutionFilterARB( params->target, params->format, params->type, params->bufSize, ULongToPtr(params->image) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnHistogram( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLboolean reset;
        GLenum format;
        GLenum type;
        GLsizei bufSize;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnHistogram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnHistogram( params->target, params->reset, params->format, params->type, params->bufSize, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnHistogramARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLboolean reset;
        GLenum format;
        GLenum type;
        GLsizei bufSize;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnHistogramARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnHistogramARB( params->target, params->reset, params->format, params->type, params->bufSize, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnMapdv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum query;
        GLsizei bufSize;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnMapdv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnMapdv( params->target, params->query, params->bufSize, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnMapdvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum query;
        GLsizei bufSize;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnMapdvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnMapdvARB( params->target, params->query, params->bufSize, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnMapfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum query;
        GLsizei bufSize;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnMapfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnMapfv( params->target, params->query, params->bufSize, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnMapfvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum query;
        GLsizei bufSize;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnMapfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnMapfvARB( params->target, params->query, params->bufSize, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnMapiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum query;
        GLsizei bufSize;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnMapiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnMapiv( params->target, params->query, params->bufSize, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnMapivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum query;
        GLsizei bufSize;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnMapivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnMapivARB( params->target, params->query, params->bufSize, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnMinmax( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLboolean reset;
        GLenum format;
        GLenum type;
        GLsizei bufSize;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnMinmax) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnMinmax( params->target, params->reset, params->format, params->type, params->bufSize, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnMinmaxARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLboolean reset;
        GLenum format;
        GLenum type;
        GLsizei bufSize;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnMinmaxARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnMinmaxARB( params->target, params->reset, params->format, params->type, params->bufSize, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnPixelMapfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum map;
        GLsizei bufSize;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnPixelMapfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnPixelMapfv( params->map, params->bufSize, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnPixelMapfvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum map;
        GLsizei bufSize;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnPixelMapfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnPixelMapfvARB( params->map, params->bufSize, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnPixelMapuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum map;
        GLsizei bufSize;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnPixelMapuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnPixelMapuiv( params->map, params->bufSize, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnPixelMapuivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum map;
        GLsizei bufSize;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnPixelMapuivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnPixelMapuivARB( params->map, params->bufSize, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnPixelMapusv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum map;
        GLsizei bufSize;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnPixelMapusv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnPixelMapusv( params->map, params->bufSize, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnPixelMapusvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum map;
        GLsizei bufSize;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnPixelMapusvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnPixelMapusvARB( params->map, params->bufSize, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnPolygonStipple( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei bufSize;
        PTR32 pattern;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnPolygonStipple) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnPolygonStipple( params->bufSize, ULongToPtr(params->pattern) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnPolygonStippleARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei bufSize;
        PTR32 pattern;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnPolygonStippleARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnPolygonStippleARB( params->bufSize, ULongToPtr(params->pattern) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnSeparableFilter( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum format;
        GLenum type;
        GLsizei rowBufSize;
        PTR32 row;
        GLsizei columnBufSize;
        PTR32 column;
        PTR32 span;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnSeparableFilter) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnSeparableFilter( params->target, params->format, params->type, params->rowBufSize, ULongToPtr(params->row), params->columnBufSize, ULongToPtr(params->column), ULongToPtr(params->span) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnSeparableFilterARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum format;
        GLenum type;
        GLsizei rowBufSize;
        PTR32 row;
        GLsizei columnBufSize;
        PTR32 column;
        PTR32 span;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnSeparableFilterARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnSeparableFilterARB( params->target, params->format, params->type, params->rowBufSize, ULongToPtr(params->row), params->columnBufSize, ULongToPtr(params->column), ULongToPtr(params->span) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnTexImage( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum format;
        GLenum type;
        GLsizei bufSize;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnTexImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnTexImage( params->target, params->level, params->format, params->type, params->bufSize, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnTexImageARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum format;
        GLenum type;
        GLsizei bufSize;
        PTR32 img;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnTexImageARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnTexImageARB( params->target, params->level, params->format, params->type, params->bufSize, ULongToPtr(params->img) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnUniformdv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei bufSize;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnUniformdv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformdv( params->program, params->location, params->bufSize, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnUniformdvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei bufSize;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnUniformdvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformdvARB( params->program, params->location, params->bufSize, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnUniformfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei bufSize;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnUniformfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformfv( params->program, params->location, params->bufSize, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnUniformfvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei bufSize;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnUniformfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformfvARB( params->program, params->location, params->bufSize, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnUniformi64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei bufSize;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnUniformi64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformi64vARB( params->program, params->location, params->bufSize, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnUniformiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei bufSize;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnUniformiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformiv( params->program, params->location, params->bufSize, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnUniformivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei bufSize;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnUniformivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformivARB( params->program, params->location, params->bufSize, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnUniformui64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei bufSize;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnUniformui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformui64vARB( params->program, params->location, params->bufSize, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnUniformuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei bufSize;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnUniformuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformuiv( params->program, params->location, params->bufSize, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGetnUniformuivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei bufSize;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGetnUniformuivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGetnUniformuivARB( params->program, params->location, params->bufSize, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGlobalAlphaFactorbSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLbyte factor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGlobalAlphaFactorbSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGlobalAlphaFactorbSUN( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGlobalAlphaFactordSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble factor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGlobalAlphaFactordSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGlobalAlphaFactordSUN( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGlobalAlphaFactorfSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat factor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGlobalAlphaFactorfSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGlobalAlphaFactorfSUN( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGlobalAlphaFactoriSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLint factor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGlobalAlphaFactoriSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGlobalAlphaFactoriSUN( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGlobalAlphaFactorsSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort factor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGlobalAlphaFactorsSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGlobalAlphaFactorsSUN( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGlobalAlphaFactorubSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLubyte factor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGlobalAlphaFactorubSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGlobalAlphaFactorubSUN( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGlobalAlphaFactoruiSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint factor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGlobalAlphaFactoruiSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGlobalAlphaFactoruiSUN( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glGlobalAlphaFactorusSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLushort factor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glGlobalAlphaFactorusSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glGlobalAlphaFactorusSUN( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glHintPGI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glHintPGI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glHintPGI( params->target, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glHistogram( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei width;
        GLenum internalformat;
        GLboolean sink;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glHistogram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glHistogram( params->target, params->width, params->internalformat, params->sink );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glHistogramEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei width;
        GLenum internalformat;
        GLboolean sink;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glHistogramEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glHistogramEXT( params->target, params->width, params->internalformat, params->sink );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIglooInterfaceSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIglooInterfaceSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIglooInterfaceSGIX( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glImageTransformParameterfHP( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glImageTransformParameterfHP) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glImageTransformParameterfHP( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glImageTransformParameterfvHP( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glImageTransformParameterfvHP) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glImageTransformParameterfvHP( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glImageTransformParameteriHP( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glImageTransformParameteriHP) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glImageTransformParameteriHP( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glImageTransformParameterivHP( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glImageTransformParameterivHP) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glImageTransformParameterivHP( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glImportMemoryWin32HandleEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint memory;
        GLuint64 size;
        GLenum handleType;
        PTR32 handle;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glImportMemoryWin32HandleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glImportMemoryWin32HandleEXT( params->memory, params->size, params->handleType, ULongToPtr(params->handle) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glImportMemoryWin32NameEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint memory;
        GLuint64 size;
        GLenum handleType;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glImportMemoryWin32NameEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glImportMemoryWin32NameEXT( params->memory, params->size, params->handleType, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glImportSemaphoreWin32HandleEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint semaphore;
        GLenum handleType;
        PTR32 handle;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glImportSemaphoreWin32HandleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glImportSemaphoreWin32HandleEXT( params->semaphore, params->handleType, ULongToPtr(params->handle) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glImportSemaphoreWin32NameEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint semaphore;
        GLenum handleType;
        PTR32 name;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glImportSemaphoreWin32NameEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glImportSemaphoreWin32NameEXT( params->semaphore, params->handleType, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glImportSyncEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum external_sync_type;
        PTR32 external_sync;
        GLbitfield flags;
        PTR32 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glImportSyncEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = (UINT_PTR)wrap_glImportSyncEXT( teb, params->external_sync_type, (GLintptr)ULongToPtr(params->external_sync), params->flags, UlongToHandle( params->ret ), funcs->p_glImportSyncEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIndexFormatNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexFormatNV( params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIndexFuncEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum func;
        GLclampf ref;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexFuncEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexFuncEXT( params->func, params->ref );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIndexMaterialEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexMaterialEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexMaterialEXT( params->face, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIndexPointerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLsizei stride;
        GLsizei count;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexPointerEXT( params->type, params->stride, params->count, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIndexPointerListIBM( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLint stride;
        PTR32 pointer;
        GLint ptrstride;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glIndexxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed component;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexxOES( params->component );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIndexxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 component;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIndexxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glIndexxvOES( ULongToPtr(params->component) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glInsertComponentEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint res;
        GLuint src;
        GLuint num;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glInsertComponentEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInsertComponentEXT( params->res, params->src, params->num );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glInsertEventMarkerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei length;
        PTR32 marker;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glInsertEventMarkerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInsertEventMarkerEXT( params->length, ULongToPtr(params->marker) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glInstrumentsBufferSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei size;
        PTR32 buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glInstrumentsBufferSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInstrumentsBufferSGIX( params->size, ULongToPtr(params->buffer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glInterpolatePathsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint resultPath;
        GLuint pathA;
        GLuint pathB;
        GLfloat weight;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glInterpolatePathsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInterpolatePathsNV( params->resultPath, params->pathA, params->pathB, params->weight );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glInvalidateBufferData( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glInvalidateBufferData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInvalidateBufferData( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glInvalidateBufferSubData( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 offset;
        PTR32 length;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glInvalidateBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInvalidateBufferSubData( params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->length) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glInvalidateFramebuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei numAttachments;
        PTR32 attachments;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glInvalidateFramebuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInvalidateFramebuffer( params->target, params->numAttachments, ULongToPtr(params->attachments) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glInvalidateNamedFramebufferData( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLsizei numAttachments;
        PTR32 attachments;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glInvalidateNamedFramebufferData) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glInvalidateNamedFramebufferData( framebuffer, params->numAttachments, ULongToPtr(params->attachments) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glInvalidateNamedFramebufferSubData( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLsizei numAttachments;
        PTR32 attachments;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glInvalidateNamedFramebufferSubData) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glInvalidateNamedFramebufferSubData( framebuffer, params->numAttachments, ULongToPtr(params->attachments), params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glInvalidateSubFramebuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei numAttachments;
        PTR32 attachments;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glInvalidateSubFramebuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInvalidateSubFramebuffer( params->target, params->numAttachments, ULongToPtr(params->attachments), params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glInvalidateTexImage( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glInvalidateTexImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInvalidateTexImage( params->texture, params->level );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glInvalidateTexSubImage( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glInvalidateTexSubImage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glInvalidateTexSubImage( params->texture, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsAsyncMarkerSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint marker;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsAsyncMarkerSGIX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsAsyncMarkerSGIX( params->marker );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsBuffer) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsBuffer( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsBufferARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsBufferARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsBufferARB( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsBufferResidentNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsBufferResidentNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsBufferResidentNV( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsCommandListNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint list;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsCommandListNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsCommandListNV( params->list );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsEnabledIndexedEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsEnabledIndexedEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsEnabledIndexedEXT( params->target, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsEnabledi( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsEnabledi) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsEnabledi( params->target, params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsFenceAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint fence;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsFenceAPPLE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsFenceAPPLE( params->fence );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsFenceNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint fence;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsFenceNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsFenceNV( params->fence );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsFramebuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsFramebuffer) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsFramebuffer( params->framebuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsFramebufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsFramebufferEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsFramebufferEXT( params->framebuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsImageHandleResidentARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint64 handle;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsImageHandleResidentARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsImageHandleResidentARB( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsImageHandleResidentNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint64 handle;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsImageHandleResidentNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsImageHandleResidentNV( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsMemoryObjectEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint memoryObject;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsMemoryObjectEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsMemoryObjectEXT( params->memoryObject );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsNameAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum identifier;
        GLuint name;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsNameAMD) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsNameAMD( params->identifier, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsNamedBufferResidentNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsNamedBufferResidentNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsNamedBufferResidentNV( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsNamedStringARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint namelen;
        PTR32 name;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsNamedStringARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsNamedStringARB( params->namelen, ULongToPtr(params->name) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsObjectBufferATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsObjectBufferATI) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsObjectBufferATI( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsOcclusionQueryNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsOcclusionQueryNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsOcclusionQueryNV( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsPathNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsPathNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsPathNV( params->path );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsPointInFillPathNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLuint mask;
        GLfloat x;
        GLfloat y;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsPointInFillPathNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsPointInFillPathNV( params->path, params->mask, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsPointInStrokePathNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLfloat x;
        GLfloat y;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsPointInStrokePathNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsPointInStrokePathNV( params->path, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsProgram( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsProgram) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsProgram( params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsProgramARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsProgramARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsProgramARB( params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsProgramNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsProgramNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsProgramNV( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsProgramPipeline( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint pipeline;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsProgramPipeline) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsProgramPipeline( params->pipeline );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsQuery( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsQuery) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsQuery( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsQueryARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsQueryARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsQueryARB( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsRenderbuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint renderbuffer;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsRenderbuffer) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsRenderbuffer( params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsRenderbufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint renderbuffer;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsRenderbufferEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsRenderbufferEXT( params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsSampler( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint sampler;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsSampler) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsSampler( params->sampler );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsSemaphoreEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint semaphore;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsSemaphoreEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsSemaphoreEXT( params->semaphore );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsShader( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint shader;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsShader) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsShader( params->shader );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsStateNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint state;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsStateNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsStateNV( params->state );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsSync( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 sync;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsSync) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsSync( get_unix_sync( ULongToPtr(params->sync) ) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsTextureEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsTextureEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsTextureEXT( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsTextureHandleResidentARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint64 handle;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsTextureHandleResidentARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsTextureHandleResidentARB( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsTextureHandleResidentNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint64 handle;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsTextureHandleResidentNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsTextureHandleResidentNV( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsTransformFeedback( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsTransformFeedback) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsTransformFeedback( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsTransformFeedbackNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsTransformFeedbackNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsTransformFeedbackNV( params->id );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsVariantEnabledEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum cap;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsVariantEnabledEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsVariantEnabledEXT( params->id, params->cap );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsVertexArray( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint array;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsVertexArray) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsVertexArray( params->array );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsVertexArrayAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint array;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsVertexArrayAPPLE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsVertexArrayAPPLE( params->array );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glIsVertexAttribEnabledAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glIsVertexAttribEnabledAPPLE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glIsVertexAttribEnabledAPPLE( params->index, params->pname );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLGPUCopyImageSubDataNVX( void *args )
{
    struct
    {
        PTR32 teb;
        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;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLGPUCopyImageSubDataNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLGPUCopyImageSubDataNVX( params->sourceGpu, params->destinationGpuMask, params->srcName, params->srcTarget, params->srcLevel, params->srcX, params->srxY, params->srcZ, params->dstName, params->dstTarget, params->dstLevel, params->dstX, params->dstY, params->dstZ, params->width, params->height, params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLGPUInterlockNVX( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLGPUInterlockNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLGPUInterlockNVX();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLGPUNamedBufferSubDataNVX( void *args )
{
    struct
    {
        PTR32 teb;
        GLbitfield gpuMask;
        GLuint buffer;
        PTR32 offset;
        PTR32 size;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLGPUNamedBufferSubDataNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLGPUNamedBufferSubDataNVX( params->gpuMask, params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLabelObjectEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLuint object;
        GLsizei length;
        PTR32 label;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLabelObjectEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLabelObjectEXT( params->type, params->object, params->length, ULongToPtr(params->label) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLightEnviSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLightEnviSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightEnviSGIX( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLightModelx( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLightModelx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightModelx( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLightModelxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLightModelxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightModelxOES( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLightModelxv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLightModelxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightModelxv( params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLightModelxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLightModelxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightModelxvOES( params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLightx( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLightx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightx( params->light, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLightxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLightxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightxOES( params->light, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLightxv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLightxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightxv( params->light, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLightxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum light;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLightxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLightxvOES( params->light, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLineWidthx( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLineWidthx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLineWidthx( params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLineWidthxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLineWidthxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLineWidthxOES( params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLinkProgram( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLinkProgram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLinkProgram( params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLinkProgramARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB programObj;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLinkProgramARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLinkProgramARB( params->programObj );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glListDrawCommandsStatesClientNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint list;
        GLuint segment;
        PTR32 indirects;
        PTR32 sizes;
        PTR32 states;
        PTR32 fbos;
        GLuint count;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const void **indirects;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glListDrawCommandsStatesClientNV) return STATUS_NOT_IMPLEMENTED;
    indirects = copy_wow64_ptr32s( params->indirects, params->count );
    funcs->p_glListDrawCommandsStatesClientNV( params->list, params->segment, indirects, ULongToPtr(params->sizes), ULongToPtr(params->states), ULongToPtr(params->fbos), params->count );
    free( indirects );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glListParameterfSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint list;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glListParameterfSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glListParameterfSGIX( params->list, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glListParameterfvSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint list;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glListParameterfvSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glListParameterfvSGIX( params->list, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glListParameteriSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint list;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glListParameteriSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glListParameteriSGIX( params->list, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glListParameterivSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint list;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glListParameterivSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glListParameterivSGIX( params->list, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLoadIdentityDeformationMapSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLbitfield mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLoadIdentityDeformationMapSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadIdentityDeformationMapSGIX( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLoadMatrixx( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLoadMatrixx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadMatrixx( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLoadMatrixxOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLoadMatrixxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadMatrixxOES( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLoadProgramNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint id;
        GLsizei len;
        PTR32 program;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLoadProgramNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadProgramNV( params->target, params->id, params->len, ULongToPtr(params->program) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLoadTransposeMatrixd( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLoadTransposeMatrixd) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadTransposeMatrixd( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLoadTransposeMatrixdARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLoadTransposeMatrixdARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadTransposeMatrixdARB( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLoadTransposeMatrixf( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLoadTransposeMatrixf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadTransposeMatrixf( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLoadTransposeMatrixfARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLoadTransposeMatrixfARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadTransposeMatrixfARB( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLoadTransposeMatrixxOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLoadTransposeMatrixxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLoadTransposeMatrixxOES( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glLockArraysEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint first;
        GLsizei count;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glLockArraysEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glLockArraysEXT( params->first, params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMTexCoord2fSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfloat s;
        GLfloat t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMTexCoord2fSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMTexCoord2fSGIS( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMTexCoord2fvSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMTexCoord2fvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMTexCoord2fvSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMakeBufferNonResidentNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMakeBufferNonResidentNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeBufferNonResidentNV( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMakeBufferResidentNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum access;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMakeBufferResidentNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeBufferResidentNV( params->target, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMakeImageHandleNonResidentARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint64 handle;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMakeImageHandleNonResidentARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeImageHandleNonResidentARB( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMakeImageHandleNonResidentNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint64 handle;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMakeImageHandleNonResidentNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeImageHandleNonResidentNV( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMakeImageHandleResidentARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint64 handle;
        GLenum access;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMakeImageHandleResidentARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeImageHandleResidentARB( params->handle, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMakeImageHandleResidentNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint64 handle;
        GLenum access;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMakeImageHandleResidentNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeImageHandleResidentNV( params->handle, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMakeNamedBufferNonResidentNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMakeNamedBufferNonResidentNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeNamedBufferNonResidentNV( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMakeNamedBufferResidentNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLenum access;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMakeNamedBufferResidentNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeNamedBufferResidentNV( params->buffer, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMakeTextureHandleNonResidentARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint64 handle;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMakeTextureHandleNonResidentARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeTextureHandleNonResidentARB( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMakeTextureHandleNonResidentNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint64 handle;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMakeTextureHandleNonResidentNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeTextureHandleNonResidentNV( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMakeTextureHandleResidentARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint64 handle;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMakeTextureHandleResidentARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeTextureHandleResidentARB( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMakeTextureHandleResidentNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint64 handle;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMakeTextureHandleResidentNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMakeTextureHandleResidentNV( params->handle );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMap1xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfixed u1;
        GLfixed u2;
        GLint stride;
        GLint order;
        GLfixed points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMap1xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMap1xOES( params->target, params->u1, params->u2, params->stride, params->order, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMap2xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfixed u1;
        GLfixed u2;
        GLint ustride;
        GLint uorder;
        GLfixed v1;
        GLfixed v2;
        GLint vstride;
        GLint vorder;
        GLfixed points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMap2xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMap2xOES( params->target, params->u1, params->u2, params->ustride, params->uorder, params->v1, params->v2, params->vstride, params->vorder, params->points );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMapBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum access;
        PTR32 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapBuffer) return STATUS_NOT_IMPLEMENTED;
    params->ret = (UINT_PTR)wow64_glMapBuffer( teb, params->target, params->access, funcs->p_glMapBuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMapBufferARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum access;
        PTR32 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapBufferARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = (UINT_PTR)wow64_glMapBuffer( teb, params->target, params->access, funcs->p_glMapBufferARB );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMapBufferRange( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 offset;
        PTR32 length;
        GLbitfield access;
        PTR32 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapBufferRange) return STATUS_NOT_IMPLEMENTED;
    params->ret = (UINT_PTR)wow64_glMapBufferRange( teb, params->target, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->length), params->access, funcs->p_glMapBufferRange );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMapControlPointsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLenum type;
        GLsizei ustride;
        GLsizei vstride;
        GLint uorder;
        GLint vorder;
        GLboolean packed;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapControlPointsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapControlPointsNV( params->target, params->index, params->type, params->ustride, params->vstride, params->uorder, params->vorder, params->packed, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMapGrid1xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLint n;
        GLfixed u1;
        GLfixed u2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapGrid1xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapGrid1xOES( params->n, params->u1, params->u2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMapGrid2xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLint n;
        GLfixed u1;
        GLfixed u2;
        GLfixed v1;
        GLfixed v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapGrid2xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapGrid2xOES( params->n, params->u1, params->u2, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMapNamedBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLenum access;
        PTR32 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapNamedBuffer) return STATUS_NOT_IMPLEMENTED;
    params->ret = (UINT_PTR)wow64_glMapNamedBuffer( teb, params->buffer, params->access, funcs->p_glMapNamedBuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMapNamedBufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLenum access;
        PTR32 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapNamedBufferEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = (UINT_PTR)wow64_glMapNamedBuffer( teb, params->buffer, params->access, funcs->p_glMapNamedBufferEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMapNamedBufferRange( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 offset;
        PTR32 length;
        GLbitfield access;
        PTR32 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapNamedBufferRange) return STATUS_NOT_IMPLEMENTED;
    params->ret = (UINT_PTR)wow64_glMapNamedBufferRange( teb, params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->length), params->access, funcs->p_glMapNamedBufferRange );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMapNamedBufferRangeEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 offset;
        PTR32 length;
        GLbitfield access;
        PTR32 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapNamedBufferRangeEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = (UINT_PTR)wow64_glMapNamedBufferRange( teb, params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->length), params->access, funcs->p_glMapNamedBufferRangeEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMapObjectBufferATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 ret;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glMapParameterfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapParameterfvNV( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMapParameterivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapParameterivNV( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMapTexture2DINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLbitfield access;
        PTR32 stride;
        PTR32 layout;
        PTR32 ret;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glMapVertexAttrib1dAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint size;
        GLdouble u1;
        GLdouble u2;
        GLint stride;
        GLint order;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapVertexAttrib1dAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapVertexAttrib1dAPPLE( params->index, params->size, params->u1, params->u2, params->stride, params->order, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMapVertexAttrib1fAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint size;
        GLfloat u1;
        GLfloat u2;
        GLint stride;
        GLint order;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapVertexAttrib1fAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapVertexAttrib1fAPPLE( params->index, params->size, params->u1, params->u2, params->stride, params->order, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMapVertexAttrib2dAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint size;
        GLdouble u1;
        GLdouble u2;
        GLint ustride;
        GLint uorder;
        GLdouble v1;
        GLdouble v2;
        GLint vstride;
        GLint vorder;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapVertexAttrib2dAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapVertexAttrib2dAPPLE( params->index, params->size, params->u1, params->u2, params->ustride, params->uorder, params->v1, params->v2, params->vstride, params->vorder, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMapVertexAttrib2fAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint size;
        GLfloat u1;
        GLfloat u2;
        GLint ustride;
        GLint uorder;
        GLfloat v1;
        GLfloat v2;
        GLint vstride;
        GLint vorder;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMapVertexAttrib2fAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMapVertexAttrib2fAPPLE( params->index, params->size, params->u1, params->u2, params->ustride, params->uorder, params->v1, params->v2, params->vstride, params->vorder, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMaterialx( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMaterialx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaterialx( params->face, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMaterialxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMaterialxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaterialxOES( params->face, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMaterialxv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMaterialxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaterialxv( params->face, params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMaterialxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMaterialxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaterialxvOES( params->face, params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixFrustumEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLdouble left;
        GLdouble right;
        GLdouble bottom;
        GLdouble top;
        GLdouble zNear;
        GLdouble zFar;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixFrustumEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixFrustumEXT( params->mode, params->left, params->right, params->bottom, params->top, params->zNear, params->zFar );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixIndexPointerARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixIndexPointerARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixIndexPointerARB( params->size, params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixIndexubvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        PTR32 indices;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixIndexubvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixIndexubvARB( params->size, ULongToPtr(params->indices) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixIndexuivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        PTR32 indices;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixIndexuivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixIndexuivARB( params->size, ULongToPtr(params->indices) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixIndexusvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        PTR32 indices;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixIndexusvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixIndexusvARB( params->size, ULongToPtr(params->indices) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixLoad3x2fNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum matrixMode;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixLoad3x2fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixLoad3x2fNV( params->matrixMode, ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixLoad3x3fNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum matrixMode;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixLoad3x3fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixLoad3x3fNV( params->matrixMode, ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixLoadIdentityEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixLoadIdentityEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixLoadIdentityEXT( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixLoadTranspose3x3fNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum matrixMode;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixLoadTranspose3x3fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixLoadTranspose3x3fNV( params->matrixMode, ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixLoadTransposedEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixLoadTransposedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixLoadTransposedEXT( params->mode, ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixLoadTransposefEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixLoadTransposefEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixLoadTransposefEXT( params->mode, ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixLoaddEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixLoaddEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixLoaddEXT( params->mode, ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixLoadfEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixLoadfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixLoadfEXT( params->mode, ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixMult3x2fNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum matrixMode;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixMult3x2fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixMult3x2fNV( params->matrixMode, ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixMult3x3fNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum matrixMode;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixMult3x3fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixMult3x3fNV( params->matrixMode, ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixMultTranspose3x3fNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum matrixMode;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixMultTranspose3x3fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixMultTranspose3x3fNV( params->matrixMode, ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixMultTransposedEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixMultTransposedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixMultTransposedEXT( params->mode, ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixMultTransposefEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixMultTransposefEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixMultTransposefEXT( params->mode, ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixMultdEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixMultdEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixMultdEXT( params->mode, ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixMultfEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixMultfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixMultfEXT( params->mode, ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixOrthoEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLdouble left;
        GLdouble right;
        GLdouble bottom;
        GLdouble top;
        GLdouble zNear;
        GLdouble zFar;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixOrthoEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixOrthoEXT( params->mode, params->left, params->right, params->bottom, params->top, params->zNear, params->zFar );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixPopEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixPopEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixPopEXT( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixPushEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixPushEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixPushEXT( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixRotatedEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLdouble angle;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixRotatedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixRotatedEXT( params->mode, params->angle, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixRotatefEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLfloat angle;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixRotatefEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixRotatefEXT( params->mode, params->angle, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixScaledEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixScaledEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixScaledEXT( params->mode, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixScalefEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixScalefEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixScalefEXT( params->mode, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixTranslatedEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixTranslatedEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixTranslatedEXT( params->mode, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMatrixTranslatefEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMatrixTranslatefEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMatrixTranslatefEXT( params->mode, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMaxShaderCompilerThreadsARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint count;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMaxShaderCompilerThreadsARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaxShaderCompilerThreadsARB( params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMaxShaderCompilerThreadsKHR( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint count;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMaxShaderCompilerThreadsKHR) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMaxShaderCompilerThreadsKHR( params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMemoryBarrier( void *args )
{
    struct
    {
        PTR32 teb;
        GLbitfield barriers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMemoryBarrier) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMemoryBarrier( params->barriers );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMemoryBarrierByRegion( void *args )
{
    struct
    {
        PTR32 teb;
        GLbitfield barriers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMemoryBarrierByRegion) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMemoryBarrierByRegion( params->barriers );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMemoryBarrierEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLbitfield barriers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMemoryBarrierEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMemoryBarrierEXT( params->barriers );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMemoryObjectParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint memoryObject;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMemoryObjectParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMemoryObjectParameterivEXT( params->memoryObject, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMinSampleShading( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMinSampleShading) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMinSampleShading( params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMinSampleShadingARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMinSampleShadingARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMinSampleShadingARB( params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMinmax( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLboolean sink;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMinmax) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMinmax( params->target, params->internalformat, params->sink );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMinmaxEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLboolean sink;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMinmaxEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMinmaxEXT( params->target, params->internalformat, params->sink );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultMatrixx( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultMatrixx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultMatrixx( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultMatrixxOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultMatrixxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultMatrixxOES( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultTransposeMatrixd( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultTransposeMatrixd) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultTransposeMatrixd( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultTransposeMatrixdARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultTransposeMatrixdARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultTransposeMatrixdARB( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultTransposeMatrixf( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultTransposeMatrixf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultTransposeMatrixf( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultTransposeMatrixfARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultTransposeMatrixfARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultTransposeMatrixfARB( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultTransposeMatrixxOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 m;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultTransposeMatrixxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultTransposeMatrixxOES( ULongToPtr(params->m) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawArrays( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 first;
        PTR32 count;
        GLsizei drawcount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawArrays) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawArrays( params->mode, ULongToPtr(params->first), ULongToPtr(params->count), params->drawcount );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawArraysEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 first;
        PTR32 count;
        GLsizei primcount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawArraysEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawArraysEXT( params->mode, ULongToPtr(params->first), ULongToPtr(params->count), params->primcount );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawArraysIndirect( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 indirect;
        GLsizei drawcount;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawArraysIndirect) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawArraysIndirect( params->mode, ULongToPtr(params->indirect), params->drawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawArraysIndirectAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 indirect;
        GLsizei primcount;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawArraysIndirectAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawArraysIndirectAMD( params->mode, ULongToPtr(params->indirect), params->primcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawArraysIndirectBindlessCountNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 indirect;
        GLsizei drawCount;
        GLsizei maxDrawCount;
        GLsizei stride;
        GLint vertexBufferCount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawArraysIndirectBindlessCountNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawArraysIndirectBindlessCountNV( params->mode, ULongToPtr(params->indirect), params->drawCount, params->maxDrawCount, params->stride, params->vertexBufferCount );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawArraysIndirectBindlessNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 indirect;
        GLsizei drawCount;
        GLsizei stride;
        GLint vertexBufferCount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawArraysIndirectBindlessNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawArraysIndirectBindlessNV( params->mode, ULongToPtr(params->indirect), params->drawCount, params->stride, params->vertexBufferCount );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawArraysIndirectCount( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 indirect;
        PTR32 drawcount;
        GLsizei maxdrawcount;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawArraysIndirectCount) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawArraysIndirectCount( params->mode, ULongToPtr(params->indirect), (GLintptr)ULongToPtr(params->drawcount), params->maxdrawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawArraysIndirectCountARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 indirect;
        PTR32 drawcount;
        GLsizei maxdrawcount;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawArraysIndirectCountARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawArraysIndirectCountARB( params->mode, ULongToPtr(params->indirect), (GLintptr)ULongToPtr(params->drawcount), params->maxdrawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawElementArrayAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 first;
        PTR32 count;
        GLsizei primcount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawElementArrayAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElementArrayAPPLE( params->mode, ULongToPtr(params->first), ULongToPtr(params->count), params->primcount );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawElements( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 count;
        GLenum type;
        PTR32 indices;
        GLsizei drawcount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const void **indices;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawElements) return STATUS_NOT_IMPLEMENTED;
    indices = copy_wow64_ptr32s( params->indices, params->drawcount );
    funcs->p_glMultiDrawElements( params->mode, ULongToPtr(params->count), params->type, indices, params->drawcount );
    free( indices );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawElementsBaseVertex( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 count;
        GLenum type;
        PTR32 indices;
        GLsizei drawcount;
        PTR32 basevertex;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const void **indices;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawElementsBaseVertex) return STATUS_NOT_IMPLEMENTED;
    indices = copy_wow64_ptr32s( params->indices, params->drawcount );
    funcs->p_glMultiDrawElementsBaseVertex( params->mode, ULongToPtr(params->count), params->type, indices, params->drawcount, ULongToPtr(params->basevertex) );
    free( indices );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawElementsEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        PTR32 count;
        GLenum type;
        PTR32 indices;
        GLsizei primcount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const void **indices;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawElementsEXT) return STATUS_NOT_IMPLEMENTED;
    indices = copy_wow64_ptr32s( params->indices, params->primcount );
    funcs->p_glMultiDrawElementsEXT( params->mode, ULongToPtr(params->count), params->type, indices, params->primcount );
    free( indices );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawElementsIndirect( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLenum type;
        PTR32 indirect;
        GLsizei drawcount;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawElementsIndirect) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElementsIndirect( params->mode, params->type, ULongToPtr(params->indirect), params->drawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawElementsIndirectAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLenum type;
        PTR32 indirect;
        GLsizei primcount;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawElementsIndirectAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElementsIndirectAMD( params->mode, params->type, ULongToPtr(params->indirect), params->primcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawElementsIndirectBindlessCountNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLenum type;
        PTR32 indirect;
        GLsizei drawCount;
        GLsizei maxDrawCount;
        GLsizei stride;
        GLint vertexBufferCount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawElementsIndirectBindlessCountNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElementsIndirectBindlessCountNV( params->mode, params->type, ULongToPtr(params->indirect), params->drawCount, params->maxDrawCount, params->stride, params->vertexBufferCount );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawElementsIndirectBindlessNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLenum type;
        PTR32 indirect;
        GLsizei drawCount;
        GLsizei stride;
        GLint vertexBufferCount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawElementsIndirectBindlessNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElementsIndirectBindlessNV( params->mode, params->type, ULongToPtr(params->indirect), params->drawCount, params->stride, params->vertexBufferCount );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawElementsIndirectCount( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLenum type;
        PTR32 indirect;
        PTR32 drawcount;
        GLsizei maxdrawcount;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawElementsIndirectCount) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElementsIndirectCount( params->mode, params->type, ULongToPtr(params->indirect), (GLintptr)ULongToPtr(params->drawcount), params->maxdrawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawElementsIndirectCountARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLenum type;
        PTR32 indirect;
        PTR32 drawcount;
        GLsizei maxdrawcount;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawElementsIndirectCountARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawElementsIndirectCountARB( params->mode, params->type, ULongToPtr(params->indirect), (GLintptr)ULongToPtr(params->drawcount), params->maxdrawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawMeshTasksIndirectCountEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 indirect;
        PTR32 drawcount;
        GLsizei maxdrawcount;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawMeshTasksIndirectCountEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawMeshTasksIndirectCountEXT( (GLintptr)ULongToPtr(params->indirect), (GLintptr)ULongToPtr(params->drawcount), params->maxdrawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawMeshTasksIndirectCountNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 indirect;
        PTR32 drawcount;
        GLsizei maxdrawcount;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawMeshTasksIndirectCountNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawMeshTasksIndirectCountNV( (GLintptr)ULongToPtr(params->indirect), (GLintptr)ULongToPtr(params->drawcount), params->maxdrawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawMeshTasksIndirectEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 indirect;
        GLsizei drawcount;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawMeshTasksIndirectEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawMeshTasksIndirectEXT( (GLintptr)ULongToPtr(params->indirect), params->drawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawMeshTasksIndirectNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 indirect;
        GLsizei drawcount;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawMeshTasksIndirectNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawMeshTasksIndirectNV( (GLintptr)ULongToPtr(params->indirect), params->drawcount, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiDrawRangeElementArrayAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLuint start;
        GLuint end;
        PTR32 first;
        PTR32 count;
        GLsizei primcount;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiDrawRangeElementArrayAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiDrawRangeElementArrayAPPLE( params->mode, params->start, params->end, ULongToPtr(params->first), ULongToPtr(params->count), params->primcount );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiModeDrawArraysIBM( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 mode;
        PTR32 first;
        PTR32 count;
        GLsizei primcount;
        GLint modestride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiModeDrawArraysIBM) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiModeDrawArraysIBM( ULongToPtr(params->mode), ULongToPtr(params->first), ULongToPtr(params->count), params->primcount, params->modestride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiModeDrawElementsIBM( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 mode;
        PTR32 count;
        GLenum type;
        PTR32 indices;
        GLsizei primcount;
        GLint modestride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const void **indices;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiModeDrawElementsIBM) return STATUS_NOT_IMPLEMENTED;
    indices = copy_wow64_ptr32s( params->indices, params->primcount );
    funcs->p_glMultiModeDrawElementsIBM( ULongToPtr(params->mode), ULongToPtr(params->count), params->type, indices, params->primcount, params->modestride );
    free( indices );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexBufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum internalformat;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexBufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexBufferEXT( params->texunit, params->target, params->internalformat, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1bOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLbyte s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1bOES( params->texture, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1bvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1bvOES( params->texture, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1d( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLdouble s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1d( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1dARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLdouble s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1dARB( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1dSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLdouble s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1dSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1dSGIS( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1dv( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1dvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1dvARB( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1dvSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1dvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1dvSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1f( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfloat s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1f( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1fARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfloat s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1fARB( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1fSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfloat s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1fSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1fSGIS( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1fv( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1fvARB( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1fvSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1fvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1fvSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLhalfNV s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1hNV( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1hvNV( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1i( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1i( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1iARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1iARB( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1iSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1iSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1iSGIS( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1iv( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1ivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1ivARB( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1ivSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1ivSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1ivSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1s( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLshort s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1s( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1sARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLshort s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1sARB( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1sSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLshort s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1sSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1sSGIS( params->target, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1sv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1sv( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1svARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1svARB( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1svSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1svSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1svSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLfixed s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1xOES( params->texture, params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord1xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord1xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord1xvOES( params->texture, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2bOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLbyte s;
        GLbyte t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2bOES( params->texture, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2bvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2bvOES( params->texture, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2d( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLdouble s;
        GLdouble t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2d( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2dARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLdouble s;
        GLdouble t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2dARB( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2dSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLdouble s;
        GLdouble t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2dSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2dSGIS( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2dv( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2dvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2dvARB( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2dvSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2dvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2dvSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2f( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfloat s;
        GLfloat t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2f( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2fARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfloat s;
        GLfloat t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2fARB( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2fSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfloat s;
        GLfloat t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2fSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2fSGIS( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2fv( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2fvARB( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2fvSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2fvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2fvSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLhalfNV s;
        GLhalfNV t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2hNV( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2hvNV( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2i( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint s;
        GLint t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2i( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2iARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint s;
        GLint t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2iARB( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2iSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint s;
        GLint t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2iSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2iSGIS( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2iv( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2ivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2ivARB( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2ivSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2ivSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2ivSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2s( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLshort s;
        GLshort t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2s( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2sARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLshort s;
        GLshort t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2sARB( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2sSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLshort s;
        GLshort t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2sSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2sSGIS( params->target, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2sv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2sv( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2svARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2svARB( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2svSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2svSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2svSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLfixed s;
        GLfixed t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2xOES( params->texture, params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord2xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord2xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord2xvOES( params->texture, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3bOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLbyte s;
        GLbyte t;
        GLbyte r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3bOES( params->texture, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3bvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3bvOES( params->texture, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3d( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLdouble s;
        GLdouble t;
        GLdouble r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3d( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3dARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLdouble s;
        GLdouble t;
        GLdouble r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3dARB( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3dSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLdouble s;
        GLdouble t;
        GLdouble r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3dSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3dSGIS( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3dv( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3dvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3dvARB( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3dvSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3dvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3dvSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3f( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfloat s;
        GLfloat t;
        GLfloat r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3f( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3fARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfloat s;
        GLfloat t;
        GLfloat r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3fARB( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3fSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfloat s;
        GLfloat t;
        GLfloat r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3fSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3fSGIS( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3fv( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3fvARB( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3fvSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3fvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3fvSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLhalfNV s;
        GLhalfNV t;
        GLhalfNV r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3hNV( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3hvNV( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3i( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint s;
        GLint t;
        GLint r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3i( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3iARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint s;
        GLint t;
        GLint r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3iARB( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3iSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint s;
        GLint t;
        GLint r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3iSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3iSGIS( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3iv( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3ivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3ivARB( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3ivSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3ivSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3ivSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3s( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLshort s;
        GLshort t;
        GLshort r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3s( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3sARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLshort s;
        GLshort t;
        GLshort r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3sARB( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3sSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLshort s;
        GLshort t;
        GLshort r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3sSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3sSGIS( params->target, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3sv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3sv( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3svARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3svARB( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3svSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3svSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3svSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLfixed s;
        GLfixed t;
        GLfixed r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3xOES( params->texture, params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord3xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord3xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord3xvOES( params->texture, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4bOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLbyte s;
        GLbyte t;
        GLbyte r;
        GLbyte q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4bOES( params->texture, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4bvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4bvOES( params->texture, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4d( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLdouble s;
        GLdouble t;
        GLdouble r;
        GLdouble q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4d( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4dARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLdouble s;
        GLdouble t;
        GLdouble r;
        GLdouble q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4dARB( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4dSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLdouble s;
        GLdouble t;
        GLdouble r;
        GLdouble q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4dSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4dSGIS( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4dv( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4dvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4dvARB( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4dvSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4dvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4dvSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4f( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfloat s;
        GLfloat t;
        GLfloat r;
        GLfloat q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4f( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4fARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfloat s;
        GLfloat t;
        GLfloat r;
        GLfloat q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4fARB( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4fSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLfloat s;
        GLfloat t;
        GLfloat r;
        GLfloat q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4fSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4fSGIS( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4fv( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4fvARB( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4fvSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4fvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4fvSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLhalfNV s;
        GLhalfNV t;
        GLhalfNV r;
        GLhalfNV q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4hNV( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4hvNV( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4i( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint s;
        GLint t;
        GLint r;
        GLint q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4i( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4iARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint s;
        GLint t;
        GLint r;
        GLint q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4iARB( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4iSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint s;
        GLint t;
        GLint r;
        GLint q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4iSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4iSGIS( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4iv( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4ivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4ivARB( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4ivSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4ivSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4ivSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4s( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLshort s;
        GLshort t;
        GLshort r;
        GLshort q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4s( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4sARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLshort s;
        GLshort t;
        GLshort r;
        GLshort q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4sARB( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4sSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLshort s;
        GLshort t;
        GLshort r;
        GLshort q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4sSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4sSGIS( params->target, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4sv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4sv( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4svARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4svARB( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4svSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4svSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4svSGIS( params->target, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4x( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLfixed s;
        GLfixed t;
        GLfixed r;
        GLfixed q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4x) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4x( params->texture, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLfixed s;
        GLfixed t;
        GLfixed r;
        GLfixed q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4xOES( params->texture, params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoord4xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoord4xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoord4xvOES( params->texture, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoordP1ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLenum type;
        GLuint coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoordP1ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordP1ui( params->texture, params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoordP1uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLenum type;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoordP1uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordP1uiv( params->texture, params->type, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoordP2ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLenum type;
        GLuint coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoordP2ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordP2ui( params->texture, params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoordP2uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLenum type;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoordP2uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordP2uiv( params->texture, params->type, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoordP3ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLenum type;
        GLuint coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoordP3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordP3ui( params->texture, params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoordP3uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLenum type;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoordP3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordP3uiv( params->texture, params->type, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoordP4ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLenum type;
        GLuint coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoordP4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordP4ui( params->texture, params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoordP4uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texture;
        GLenum type;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoordP4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordP4uiv( params->texture, params->type, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoordPointerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoordPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordPointerEXT( params->texunit, params->size, params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexCoordPointerSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexCoordPointerSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexCoordPointerSGIS( params->target, params->size, params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexEnvfEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexEnvfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexEnvfEXT( params->texunit, params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexEnvfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexEnvfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexEnvfvEXT( params->texunit, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexEnviEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexEnviEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexEnviEXT( params->texunit, params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexEnvivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexEnvivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexEnvivEXT( params->texunit, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexGendEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum coord;
        GLenum pname;
        GLdouble param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexGendEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexGendEXT( params->texunit, params->coord, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexGendvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum coord;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexGendvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexGendvEXT( params->texunit, params->coord, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexGenfEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum coord;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexGenfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexGenfEXT( params->texunit, params->coord, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexGenfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum coord;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexGenfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexGenfvEXT( params->texunit, params->coord, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexGeniEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum coord;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexGeniEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexGeniEXT( params->texunit, params->coord, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexGenivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum coord;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexGenivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexGenivEXT( params->texunit, params->coord, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexImage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLint internalformat;
        GLsizei width;
        GLint border;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexImage1DEXT( params->texunit, params->target, params->level, params->internalformat, params->width, params->border, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexImage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLint internalformat;
        GLsizei width;
        GLsizei height;
        GLint border;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexImage2DEXT( params->texunit, params->target, params->level, params->internalformat, params->width, params->height, params->border, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexImage3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLint internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLint border;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexImage3DEXT( params->texunit, params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->border, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexParameterIivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexParameterIivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexParameterIivEXT( params->texunit, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexParameterIuivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexParameterIuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexParameterIuivEXT( params->texunit, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexParameterfEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexParameterfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexParameterfEXT( params->texunit, params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexParameterfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexParameterfvEXT( params->texunit, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexParameteriEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexParameteriEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexParameteriEXT( params->texunit, params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexParameterivEXT( params->texunit, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexRenderbufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLuint renderbuffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexRenderbufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexRenderbufferEXT( params->texunit, params->target, params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexSubImage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLsizei width;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexSubImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexSubImage1DEXT( params->texunit, params->target, params->level, params->xoffset, params->width, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexSubImage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexSubImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexSubImage2DEXT( params->texunit, params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMultiTexSubImage3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texunit;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMultiTexSubImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMultiTexSubImage3DEXT( params->texunit, params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMulticastBarrierNV( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMulticastBarrierNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastBarrierNV();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMulticastBlitFramebufferNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint srcGpu;
        GLuint dstGpu;
        GLint srcX0;
        GLint srcY0;
        GLint srcX1;
        GLint srcY1;
        GLint dstX0;
        GLint dstY0;
        GLint dstX1;
        GLint dstY1;
        GLbitfield mask;
        GLenum filter;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMulticastBlitFramebufferNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastBlitFramebufferNV( params->srcGpu, params->dstGpu, params->srcX0, params->srcY0, params->srcX1, params->srcY1, params->dstX0, params->dstY0, params->dstX1, params->dstY1, params->mask, params->filter );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMulticastBufferSubDataNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLbitfield gpuMask;
        GLuint buffer;
        PTR32 offset;
        PTR32 size;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMulticastBufferSubDataNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastBufferSubDataNV( params->gpuMask, params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMulticastCopyBufferSubDataNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint readGpu;
        GLbitfield writeGpuMask;
        GLuint readBuffer;
        GLuint writeBuffer;
        PTR32 readOffset;
        PTR32 writeOffset;
        PTR32 size;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMulticastCopyBufferSubDataNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastCopyBufferSubDataNV( params->readGpu, params->writeGpuMask, params->readBuffer, params->writeBuffer, (GLintptr)ULongToPtr(params->readOffset), (GLintptr)ULongToPtr(params->writeOffset), (GLsizeiptr)ULongToPtr(params->size) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMulticastCopyImageSubDataNV( void *args )
{
    struct
    {
        PTR32 teb;
        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;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMulticastCopyImageSubDataNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastCopyImageSubDataNV( params->srcGpu, params->dstGpuMask, params->srcName, params->srcTarget, params->srcLevel, params->srcX, params->srcY, params->srcZ, params->dstName, params->dstTarget, params->dstLevel, params->dstX, params->dstY, params->dstZ, params->srcWidth, params->srcHeight, params->srcDepth );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMulticastFramebufferSampleLocationsfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint gpu;
        GLuint framebuffer;
        GLuint start;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMulticastFramebufferSampleLocationsfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastFramebufferSampleLocationsfvNV( params->gpu, params->framebuffer, params->start, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMulticastGetQueryObjecti64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint gpu;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMulticastGetQueryObjecti64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastGetQueryObjecti64vNV( params->gpu, params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMulticastGetQueryObjectivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint gpu;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMulticastGetQueryObjectivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastGetQueryObjectivNV( params->gpu, params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMulticastGetQueryObjectui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint gpu;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMulticastGetQueryObjectui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastGetQueryObjectui64vNV( params->gpu, params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMulticastGetQueryObjectuivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint gpu;
        GLuint id;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMulticastGetQueryObjectuivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastGetQueryObjectuivNV( params->gpu, params->id, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMulticastScissorArrayvNVX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint gpu;
        GLuint first;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMulticastScissorArrayvNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastScissorArrayvNVX( params->gpu, params->first, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMulticastViewportArrayvNVX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint gpu;
        GLuint first;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMulticastViewportArrayvNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastViewportArrayvNVX( params->gpu, params->first, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMulticastViewportPositionWScaleNVX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint gpu;
        GLuint index;
        GLfloat xcoeff;
        GLfloat ycoeff;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMulticastViewportPositionWScaleNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastViewportPositionWScaleNVX( params->gpu, params->index, params->xcoeff, params->ycoeff );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glMulticastWaitSyncNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint signalGpu;
        GLbitfield waitGpuMask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glMulticastWaitSyncNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glMulticastWaitSyncNV( params->signalGpu, params->waitGpuMask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedBufferAttachMemoryNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLuint memory;
        GLuint64 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedBufferAttachMemoryNV) return STATUS_NOT_IMPLEMENTED;
    wow64_glNamedBufferAttachMemoryNV( teb, params->buffer, params->memory, params->offset, funcs->p_glNamedBufferAttachMemoryNV );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedBufferData( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 size;
        PTR32 data;
        GLenum usage;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedBufferData) return STATUS_NOT_IMPLEMENTED;
    wow64_glNamedBufferData( teb, params->buffer, (GLsizeiptr)ULongToPtr(params->size), ULongToPtr(params->data), params->usage, funcs->p_glNamedBufferData );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedBufferDataEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 size;
        PTR32 data;
        GLenum usage;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedBufferDataEXT) return STATUS_NOT_IMPLEMENTED;
    wow64_glNamedBufferData( teb, params->buffer, (GLsizeiptr)ULongToPtr(params->size), ULongToPtr(params->data), params->usage, funcs->p_glNamedBufferDataEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedBufferPageCommitmentARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 offset;
        PTR32 size;
        GLboolean commit;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedBufferPageCommitmentARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedBufferPageCommitmentARB( params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedBufferPageCommitmentEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 offset;
        PTR32 size;
        GLboolean commit;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedBufferPageCommitmentEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedBufferPageCommitmentEXT( params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedBufferPageCommitmentMemNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 offset;
        PTR32 size;
        GLuint memory;
        GLuint64 memOffset;
        GLboolean commit;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedBufferPageCommitmentMemNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedBufferPageCommitmentMemNV( params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), params->memory, params->memOffset, params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedBufferStorage( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 size;
        PTR32 data;
        GLbitfield flags;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedBufferStorage) return STATUS_NOT_IMPLEMENTED;
    wow64_glNamedBufferStorage( teb, params->buffer, (GLsizeiptr)ULongToPtr(params->size), ULongToPtr(params->data), params->flags, funcs->p_glNamedBufferStorage );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedBufferStorageEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 size;
        PTR32 data;
        GLbitfield flags;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedBufferStorageEXT) return STATUS_NOT_IMPLEMENTED;
    wow64_glNamedBufferStorage( teb, params->buffer, (GLsizeiptr)ULongToPtr(params->size), ULongToPtr(params->data), params->flags, funcs->p_glNamedBufferStorageEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedBufferStorageMemEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 size;
        GLuint memory;
        GLuint64 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedBufferStorageMemEXT) return STATUS_NOT_IMPLEMENTED;
    wow64_glNamedBufferStorageMemEXT( teb, params->buffer, (GLsizeiptr)ULongToPtr(params->size), params->memory, params->offset, funcs->p_glNamedBufferStorageMemEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedBufferSubData( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 offset;
        PTR32 size;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedBufferSubData) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedBufferSubData( params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedBufferSubDataEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        PTR32 offset;
        PTR32 size;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedBufferSubDataEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedBufferSubDataEXT( params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size), ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedCopyBufferSubDataEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint readBuffer;
        GLuint writeBuffer;
        PTR32 readOffset;
        PTR32 writeOffset;
        PTR32 size;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedCopyBufferSubDataEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedCopyBufferSubDataEXT( params->readBuffer, params->writeBuffer, (GLintptr)ULongToPtr(params->readOffset), (GLintptr)ULongToPtr(params->writeOffset), (GLsizeiptr)ULongToPtr(params->size) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferDrawBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum buf;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferDrawBuffer) return STATUS_NOT_IMPLEMENTED;
    wrap_glNamedFramebufferDrawBuffer( teb, params->framebuffer, params->buf, funcs->p_glNamedFramebufferDrawBuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferDrawBuffers( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLsizei n;
        PTR32 bufs;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferDrawBuffers) return STATUS_NOT_IMPLEMENTED;
    wrap_glNamedFramebufferDrawBuffers( teb, params->framebuffer, params->n, ULongToPtr(params->bufs), funcs->p_glNamedFramebufferDrawBuffers );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferParameteri( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferParameteri) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glNamedFramebufferParameteri( framebuffer, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferParameteriEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferParameteriEXT) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glNamedFramebufferParameteriEXT( framebuffer, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferReadBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum src;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferReadBuffer) return STATUS_NOT_IMPLEMENTED;
    wrap_glNamedFramebufferReadBuffer( teb, params->framebuffer, params->src, funcs->p_glNamedFramebufferReadBuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferRenderbuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum attachment;
        GLenum renderbuffertarget;
        GLuint renderbuffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferRenderbuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferRenderbuffer( params->framebuffer, params->attachment, params->renderbuffertarget, params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferRenderbufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum attachment;
        GLenum renderbuffertarget;
        GLuint renderbuffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferRenderbufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferRenderbufferEXT( params->framebuffer, params->attachment, params->renderbuffertarget, params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferSampleLocationsfvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLuint start;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferSampleLocationsfvARB) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glNamedFramebufferSampleLocationsfvARB( framebuffer, params->start, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferSampleLocationsfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLuint start;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferSampleLocationsfvNV) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glNamedFramebufferSampleLocationsfvNV( framebuffer, params->start, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferSamplePositionsfvAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLuint numsamples;
        GLuint pixelindex;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferSamplePositionsfvAMD) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glNamedFramebufferSamplePositionsfvAMD( framebuffer, params->numsamples, params->pixelindex, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferTexture( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum attachment;
        GLuint texture;
        GLint level;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferTexture) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferTexture( params->framebuffer, params->attachment, params->texture, params->level );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferTexture1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum attachment;
        GLenum textarget;
        GLuint texture;
        GLint level;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferTexture1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferTexture1DEXT( params->framebuffer, params->attachment, params->textarget, params->texture, params->level );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferTexture2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum attachment;
        GLenum textarget;
        GLuint texture;
        GLint level;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferTexture2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferTexture2DEXT( params->framebuffer, params->attachment, params->textarget, params->texture, params->level );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferTexture3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum attachment;
        GLenum textarget;
        GLuint texture;
        GLint level;
        GLint zoffset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferTexture3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferTexture3DEXT( params->framebuffer, params->attachment, params->textarget, params->texture, params->level, params->zoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferTextureEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum attachment;
        GLuint texture;
        GLint level;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferTextureEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferTextureEXT( params->framebuffer, params->attachment, params->texture, params->level );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferTextureFaceEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum attachment;
        GLuint texture;
        GLint level;
        GLenum face;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferTextureFaceEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferTextureFaceEXT( params->framebuffer, params->attachment, params->texture, params->level, params->face );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferTextureLayer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum attachment;
        GLuint texture;
        GLint level;
        GLint layer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferTextureLayer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferTextureLayer( params->framebuffer, params->attachment, params->texture, params->level, params->layer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferTextureLayerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum attachment;
        GLuint texture;
        GLint level;
        GLint layer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferTextureLayerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedFramebufferTextureLayerEXT( params->framebuffer, params->attachment, params->texture, params->level, params->layer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedFramebufferTextureMultiviewOVR( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint framebuffer;
        GLenum attachment;
        GLuint texture;
        GLint level;
        GLint baseViewIndex;
        GLsizei numViews;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLuint framebuffer = params->framebuffer;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedFramebufferTextureMultiviewOVR) return STATUS_NOT_IMPLEMENTED;
    if (!framebuffer) framebuffer = get_default_fbo( teb, GL_DRAW_FRAMEBUFFER );
    funcs->p_glNamedFramebufferTextureMultiviewOVR( framebuffer, params->attachment, params->texture, params->level, params->baseViewIndex, params->numViews );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedProgramLocalParameter4dEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLuint index;
        GLdouble x;
        GLdouble y;
        GLdouble z;
        GLdouble w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameter4dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameter4dEXT( params->program, params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedProgramLocalParameter4dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameter4dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameter4dvEXT( params->program, params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedProgramLocalParameter4fEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLuint index;
        GLfloat x;
        GLfloat y;
        GLfloat z;
        GLfloat w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameter4fEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameter4fEXT( params->program, params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedProgramLocalParameter4fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameter4fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameter4fvEXT( params->program, params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedProgramLocalParameterI4iEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLuint index;
        GLint x;
        GLint y;
        GLint z;
        GLint w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameterI4iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameterI4iEXT( params->program, params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedProgramLocalParameterI4ivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameterI4ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameterI4ivEXT( params->program, params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedProgramLocalParameterI4uiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLuint index;
        GLuint x;
        GLuint y;
        GLuint z;
        GLuint w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameterI4uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameterI4uiEXT( params->program, params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedProgramLocalParameterI4uivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameterI4uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameterI4uivEXT( params->program, params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedProgramLocalParameters4fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLuint index;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedProgramLocalParameters4fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParameters4fvEXT( params->program, params->target, params->index, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedProgramLocalParametersI4ivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLuint index;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedProgramLocalParametersI4ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParametersI4ivEXT( params->program, params->target, params->index, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedProgramLocalParametersI4uivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLuint index;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedProgramLocalParametersI4uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramLocalParametersI4uivEXT( params->program, params->target, params->index, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedProgramStringEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum target;
        GLenum format;
        GLsizei len;
        PTR32 string;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedProgramStringEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedProgramStringEXT( params->program, params->target, params->format, params->len, ULongToPtr(params->string) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedRenderbufferStorage( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint renderbuffer;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedRenderbufferStorage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedRenderbufferStorage( params->renderbuffer, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedRenderbufferStorageEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint renderbuffer;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedRenderbufferStorageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedRenderbufferStorageEXT( params->renderbuffer, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedRenderbufferStorageMultisample( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint renderbuffer;
        GLsizei samples;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedRenderbufferStorageMultisample) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedRenderbufferStorageMultisample( params->renderbuffer, params->samples, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedRenderbufferStorageMultisampleAdvancedAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint renderbuffer;
        GLsizei samples;
        GLsizei storageSamples;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedRenderbufferStorageMultisampleAdvancedAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedRenderbufferStorageMultisampleAdvancedAMD( params->renderbuffer, params->samples, params->storageSamples, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedRenderbufferStorageMultisampleCoverageEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint renderbuffer;
        GLsizei coverageSamples;
        GLsizei colorSamples;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedRenderbufferStorageMultisampleCoverageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedRenderbufferStorageMultisampleCoverageEXT( params->renderbuffer, params->coverageSamples, params->colorSamples, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedRenderbufferStorageMultisampleEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint renderbuffer;
        GLsizei samples;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedRenderbufferStorageMultisampleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedRenderbufferStorageMultisampleEXT( params->renderbuffer, params->samples, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNamedStringARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLint namelen;
        PTR32 name;
        GLint stringlen;
        PTR32 string;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNamedStringARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNamedStringARB( params->type, params->namelen, ULongToPtr(params->name), params->stringlen, ULongToPtr(params->string) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNewBufferRegion( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNewBufferRegion) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glNewBufferRegion( params->type );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNewObjectBufferATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei size;
        PTR32 pointer;
        GLenum usage;
        GLuint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNewObjectBufferATI) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glNewObjectBufferATI( params->size, ULongToPtr(params->pointer), params->usage );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormal3fVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat nx;
        GLfloat ny;
        GLfloat nz;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3fVertex3fSUN( params->nx, params->ny, params->nz, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormal3fVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 n;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3fVertex3fvSUN( ULongToPtr(params->n), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormal3hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLhalfNV nx;
        GLhalfNV ny;
        GLhalfNV nz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3hNV( params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormal3hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3hvNV( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormal3x( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed nx;
        GLfixed ny;
        GLfixed nz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3x) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3x( params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormal3xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed nx;
        GLfixed ny;
        GLfixed nz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3xOES( params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormal3xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormal3xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormal3xvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormalFormatNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormalFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalFormatNV( params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormalP3ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLuint coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormalP3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalP3ui( params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormalP3uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormalP3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalP3uiv( params->type, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormalPointerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLsizei stride;
        GLsizei count;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormalPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalPointerEXT( params->type, params->stride, params->count, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormalPointerListIBM( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLint stride;
        PTR32 pointer;
        GLint ptrstride;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glNormalPointervINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        PTR32 pointer;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glNormalStream3bATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLbyte nx;
        GLbyte ny;
        GLbyte nz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormalStream3bATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3bATI( params->stream, params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormalStream3bvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormalStream3bvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3bvATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormalStream3dATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLdouble nx;
        GLdouble ny;
        GLdouble nz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormalStream3dATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3dATI( params->stream, params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormalStream3dvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormalStream3dvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3dvATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormalStream3fATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLfloat nx;
        GLfloat ny;
        GLfloat nz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormalStream3fATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3fATI( params->stream, params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormalStream3fvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormalStream3fvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3fvATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormalStream3iATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLint nx;
        GLint ny;
        GLint nz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormalStream3iATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3iATI( params->stream, params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormalStream3ivATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormalStream3ivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3ivATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormalStream3sATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLshort nx;
        GLshort ny;
        GLshort nz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormalStream3sATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3sATI( params->stream, params->nx, params->ny, params->nz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glNormalStream3svATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glNormalStream3svATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glNormalStream3svATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glObjectLabel( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum identifier;
        GLuint name;
        GLsizei length;
        PTR32 label;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glObjectLabel) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glObjectLabel( params->identifier, params->name, params->length, ULongToPtr(params->label) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glObjectPtrLabel( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 ptr;
        GLsizei length;
        PTR32 label;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glObjectPtrLabel) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glObjectPtrLabel( ULongToPtr(params->ptr), params->length, ULongToPtr(params->label) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glObjectPurgeableAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum objectType;
        GLuint name;
        GLenum option;
        GLenum ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glObjectPurgeableAPPLE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glObjectPurgeableAPPLE( params->objectType, params->name, params->option );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glObjectUnpurgeableAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum objectType;
        GLuint name;
        GLenum option;
        GLenum ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glObjectUnpurgeableAPPLE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glObjectUnpurgeableAPPLE( params->objectType, params->name, params->option );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glOrthof( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat l;
        GLfloat r;
        GLfloat b;
        GLfloat t;
        GLfloat n;
        GLfloat f;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glOrthof) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glOrthof( params->l, params->r, params->b, params->t, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glOrthofOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat l;
        GLfloat r;
        GLfloat b;
        GLfloat t;
        GLfloat n;
        GLfloat f;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glOrthofOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glOrthofOES( params->l, params->r, params->b, params->t, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glOrthox( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed l;
        GLfixed r;
        GLfixed b;
        GLfixed t;
        GLfixed n;
        GLfixed f;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glOrthox) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glOrthox( params->l, params->r, params->b, params->t, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glOrthoxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed l;
        GLfixed r;
        GLfixed b;
        GLfixed t;
        GLfixed n;
        GLfixed f;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glOrthoxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glOrthoxOES( params->l, params->r, params->b, params->t, params->n, params->f );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPNTrianglesfATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPNTrianglesfATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPNTrianglesfATI( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPNTrianglesiATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPNTrianglesiATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPNTrianglesiATI( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPassTexCoordATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint dst;
        GLuint coord;
        GLenum swizzle;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPassTexCoordATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPassTexCoordATI( params->dst, params->coord, params->swizzle );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPassThroughxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed token;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPassThroughxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPassThroughxOES( params->token );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPatchParameterfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPatchParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPatchParameterfv( params->pname, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPatchParameteri( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPatchParameteri) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPatchParameteri( params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathColorGenNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum color;
        GLenum genMode;
        GLenum colorFormat;
        PTR32 coeffs;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathColorGenNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathColorGenNV( params->color, params->genMode, params->colorFormat, ULongToPtr(params->coeffs) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathCommandsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLsizei numCommands;
        PTR32 commands;
        GLsizei numCoords;
        GLenum coordType;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathCommandsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathCommandsNV( params->path, params->numCommands, ULongToPtr(params->commands), params->numCoords, params->coordType, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathCoordsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLsizei numCoords;
        GLenum coordType;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathCoordsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathCoordsNV( params->path, params->numCoords, params->coordType, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathCoverDepthFuncNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum func;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathCoverDepthFuncNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathCoverDepthFuncNV( params->func );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathDashArrayNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLsizei dashCount;
        PTR32 dashArray;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathDashArrayNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathDashArrayNV( params->path, params->dashCount, ULongToPtr(params->dashArray) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathFogGenNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum genMode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathFogGenNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathFogGenNV( params->genMode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathGlyphIndexArrayNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint firstPathName;
        GLenum fontTarget;
        PTR32 fontName;
        GLbitfield fontStyle;
        GLuint firstGlyphIndex;
        GLsizei numGlyphs;
        GLuint pathParameterTemplate;
        GLfloat emScale;
        GLenum ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathGlyphIndexArrayNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glPathGlyphIndexArrayNV( params->firstPathName, params->fontTarget, ULongToPtr(params->fontName), params->fontStyle, params->firstGlyphIndex, params->numGlyphs, params->pathParameterTemplate, params->emScale );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathGlyphIndexRangeNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum fontTarget;
        PTR32 fontName;
        GLbitfield fontStyle;
        GLuint pathParameterTemplate;
        GLfloat emScale;
        PTR32 baseAndCount;
        GLenum ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathGlyphIndexRangeNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glPathGlyphIndexRangeNV( params->fontTarget, ULongToPtr(params->fontName), params->fontStyle, params->pathParameterTemplate, params->emScale, ULongToPtr(params->baseAndCount) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathGlyphRangeNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint firstPathName;
        GLenum fontTarget;
        PTR32 fontName;
        GLbitfield fontStyle;
        GLuint firstGlyph;
        GLsizei numGlyphs;
        GLenum handleMissingGlyphs;
        GLuint pathParameterTemplate;
        GLfloat emScale;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathGlyphRangeNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathGlyphRangeNV( params->firstPathName, params->fontTarget, ULongToPtr(params->fontName), params->fontStyle, params->firstGlyph, params->numGlyphs, params->handleMissingGlyphs, params->pathParameterTemplate, params->emScale );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathGlyphsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint firstPathName;
        GLenum fontTarget;
        PTR32 fontName;
        GLbitfield fontStyle;
        GLsizei numGlyphs;
        GLenum type;
        PTR32 charcodes;
        GLenum handleMissingGlyphs;
        GLuint pathParameterTemplate;
        GLfloat emScale;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathGlyphsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathGlyphsNV( params->firstPathName, params->fontTarget, ULongToPtr(params->fontName), params->fontStyle, params->numGlyphs, params->type, ULongToPtr(params->charcodes), params->handleMissingGlyphs, params->pathParameterTemplate, params->emScale );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathMemoryGlyphIndexArrayNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint firstPathName;
        GLenum fontTarget;
        PTR32 fontSize;
        PTR32 fontData;
        GLsizei faceIndex;
        GLuint firstGlyphIndex;
        GLsizei numGlyphs;
        GLuint pathParameterTemplate;
        GLfloat emScale;
        GLenum ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathMemoryGlyphIndexArrayNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glPathMemoryGlyphIndexArrayNV( params->firstPathName, params->fontTarget, (GLsizeiptr)ULongToPtr(params->fontSize), ULongToPtr(params->fontData), params->faceIndex, params->firstGlyphIndex, params->numGlyphs, params->pathParameterTemplate, params->emScale );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathParameterfNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLenum pname;
        GLfloat value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathParameterfNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathParameterfNV( params->path, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathParameterfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLenum pname;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathParameterfvNV( params->path, params->pname, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathParameteriNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLenum pname;
        GLint value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathParameteriNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathParameteriNV( params->path, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathParameterivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLenum pname;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathParameterivNV( params->path, params->pname, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathStencilDepthOffsetNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat factor;
        GLfloat units;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathStencilDepthOffsetNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathStencilDepthOffsetNV( params->factor, params->units );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathStencilFuncNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum func;
        GLint ref;
        GLuint mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathStencilFuncNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathStencilFuncNV( params->func, params->ref, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathStringNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLenum format;
        GLsizei length;
        PTR32 pathString;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathStringNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathStringNV( params->path, params->format, params->length, ULongToPtr(params->pathString) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathSubCommandsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLsizei commandStart;
        GLsizei commandsToDelete;
        GLsizei numCommands;
        PTR32 commands;
        GLsizei numCoords;
        GLenum coordType;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathSubCommandsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathSubCommandsNV( params->path, params->commandStart, params->commandsToDelete, params->numCommands, ULongToPtr(params->commands), params->numCoords, params->coordType, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathSubCoordsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLsizei coordStart;
        GLsizei numCoords;
        GLenum coordType;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathSubCoordsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathSubCoordsNV( params->path, params->coordStart, params->numCoords, params->coordType, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPathTexGenNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum texCoordSet;
        GLenum genMode;
        GLint components;
        PTR32 coeffs;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPathTexGenNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPathTexGenNV( params->texCoordSet, params->genMode, params->components, ULongToPtr(params->coeffs) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPauseTransformFeedback( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPauseTransformFeedback) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPauseTransformFeedback();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPauseTransformFeedbackNV( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPauseTransformFeedbackNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPauseTransformFeedbackNV();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPixelDataRangeNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei length;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelDataRangeNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelDataRangeNV( params->target, params->length, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPixelMapx( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum map;
        GLint size;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelMapx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelMapx( params->map, params->size, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPixelStorex( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelStorex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelStorex( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPixelTexGenParameterfSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelTexGenParameterfSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTexGenParameterfSGIS( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPixelTexGenParameterfvSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelTexGenParameterfvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTexGenParameterfvSGIS( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPixelTexGenParameteriSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelTexGenParameteriSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTexGenParameteriSGIS( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPixelTexGenParameterivSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelTexGenParameterivSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTexGenParameterivSGIS( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPixelTexGenSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelTexGenSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTexGenSGIX( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPixelTransferxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelTransferxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTransferxOES( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPixelTransformParameterfEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelTransformParameterfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTransformParameterfEXT( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPixelTransformParameterfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelTransformParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTransformParameterfvEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPixelTransformParameteriEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelTransformParameteriEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTransformParameteriEXT( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPixelTransformParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelTransformParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelTransformParameterivEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPixelZoomxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed xfactor;
        GLfixed yfactor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPixelZoomxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPixelZoomxOES( params->xfactor, params->yfactor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointAlongPathNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLsizei startSegment;
        GLsizei numSegments;
        GLfloat distance;
        PTR32 x;
        PTR32 y;
        PTR32 tangentX;
        PTR32 tangentY;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointAlongPathNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glPointAlongPathNV( params->path, params->startSegment, params->numSegments, params->distance, ULongToPtr(params->x), ULongToPtr(params->y), ULongToPtr(params->tangentX), ULongToPtr(params->tangentY) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointParameterf( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointParameterf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterf( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointParameterfARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointParameterfARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterfARB( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointParameterfEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointParameterfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterfEXT( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointParameterfSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointParameterfSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterfSGIS( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointParameterfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterfv( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointParameterfvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointParameterfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterfvARB( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointParameterfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterfvEXT( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointParameterfvSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointParameterfvSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterfvSGIS( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointParameteri( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointParameteri) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameteri( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointParameteriNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointParameteriNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameteriNV( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameteriv( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointParameterivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterivNV( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointParameterx( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointParameterx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterx( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointParameterxv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointParameterxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterxv( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointParameterxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointParameterxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointParameterxvOES( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointSizex( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed size;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointSizex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointSizex( params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPointSizexOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed size;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPointSizexOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPointSizexOES( params->size );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPollAsyncSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 markerp;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPollAsyncSGIX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glPollAsyncSGIX( ULongToPtr(params->markerp) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPollInstrumentsSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 marker_p;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPollInstrumentsSGIX) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glPollInstrumentsSGIX( ULongToPtr(params->marker_p) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPolygonOffsetClamp( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat factor;
        GLfloat units;
        GLfloat clamp;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPolygonOffsetClamp) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPolygonOffsetClamp( params->factor, params->units, params->clamp );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPolygonOffsetClampEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat factor;
        GLfloat units;
        GLfloat clamp;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPolygonOffsetClampEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPolygonOffsetClampEXT( params->factor, params->units, params->clamp );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPolygonOffsetEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat factor;
        GLfloat bias;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPolygonOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPolygonOffsetEXT( params->factor, params->bias );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPolygonOffsetx( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed factor;
        GLfixed units;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPolygonOffsetx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPolygonOffsetx( params->factor, params->units );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPolygonOffsetxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed factor;
        GLfixed units;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPolygonOffsetxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPolygonOffsetxOES( params->factor, params->units );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPopDebugGroup( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPopDebugGroup) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPopDebugGroup();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPopGroupMarkerEXT( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPopGroupMarkerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPopGroupMarkerEXT();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPresentFrameDualFillNV( void *args )
{
    struct
    {
        PTR32 teb;
        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;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPresentFrameDualFillNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPresentFrameDualFillNV( params->video_slot, params->minPresentTime, params->beginPresentTimeId, params->presentDurationId, params->type, params->target0, params->fill0, params->target1, params->fill1, params->target2, params->fill2, params->target3, params->fill3 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPresentFrameKeyedNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_slot;
        GLuint64EXT minPresentTime;
        GLuint beginPresentTimeId;
        GLuint presentDurationId;
        GLenum type;
        GLenum target0;
        GLuint fill0;
        GLuint key0;
        GLenum target1;
        GLuint fill1;
        GLuint key1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPresentFrameKeyedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPresentFrameKeyedNV( params->video_slot, params->minPresentTime, params->beginPresentTimeId, params->presentDurationId, params->type, params->target0, params->fill0, params->key0, params->target1, params->fill1, params->key1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPrimitiveBoundingBox( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat minX;
        GLfloat minY;
        GLfloat minZ;
        GLfloat minW;
        GLfloat maxX;
        GLfloat maxY;
        GLfloat maxZ;
        GLfloat maxW;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPrimitiveBoundingBox) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPrimitiveBoundingBox( params->minX, params->minY, params->minZ, params->minW, params->maxX, params->maxY, params->maxZ, params->maxW );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPrimitiveBoundingBoxARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat minX;
        GLfloat minY;
        GLfloat minZ;
        GLfloat minW;
        GLfloat maxX;
        GLfloat maxY;
        GLfloat maxZ;
        GLfloat maxW;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPrimitiveBoundingBoxARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPrimitiveBoundingBoxARB( params->minX, params->minY, params->minZ, params->minW, params->maxX, params->maxY, params->maxZ, params->maxW );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPrimitiveRestartIndex( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPrimitiveRestartIndex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPrimitiveRestartIndex( params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPrimitiveRestartIndexNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPrimitiveRestartIndexNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPrimitiveRestartIndexNV( params->index );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPrimitiveRestartNV( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPrimitiveRestartNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPrimitiveRestartNV();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPrioritizeTexturesEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 textures;
        PTR32 priorities;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPrioritizeTexturesEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPrioritizeTexturesEXT( params->n, ULongToPtr(params->textures), ULongToPtr(params->priorities) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPrioritizeTexturesxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 textures;
        PTR32 priorities;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPrioritizeTexturesxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPrioritizeTexturesxOES( params->n, ULongToPtr(params->textures), ULongToPtr(params->priorities) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramBinary( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum binaryFormat;
        PTR32 binary;
        GLsizei length;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramBinary) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramBinary( params->program, params->binaryFormat, ULongToPtr(params->binary), params->length );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramBufferParametersIivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint bindingIndex;
        GLuint wordIndex;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramBufferParametersIivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramBufferParametersIivNV( params->target, params->bindingIndex, params->wordIndex, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramBufferParametersIuivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint bindingIndex;
        GLuint wordIndex;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramBufferParametersIuivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramBufferParametersIuivNV( params->target, params->bindingIndex, params->wordIndex, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramBufferParametersfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint bindingIndex;
        GLuint wordIndex;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramBufferParametersfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramBufferParametersfvNV( params->target, params->bindingIndex, params->wordIndex, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramEnvParameter4dARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLdouble x;
        GLdouble y;
        GLdouble z;
        GLdouble w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramEnvParameter4dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameter4dARB( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramEnvParameter4dvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramEnvParameter4dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameter4dvARB( params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramEnvParameter4fARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLfloat x;
        GLfloat y;
        GLfloat z;
        GLfloat w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramEnvParameter4fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameter4fARB( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramEnvParameter4fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramEnvParameter4fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameter4fvARB( params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramEnvParameterI4iNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLint x;
        GLint y;
        GLint z;
        GLint w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramEnvParameterI4iNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameterI4iNV( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramEnvParameterI4ivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramEnvParameterI4ivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameterI4ivNV( params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramEnvParameterI4uiNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLuint x;
        GLuint y;
        GLuint z;
        GLuint w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramEnvParameterI4uiNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameterI4uiNV( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramEnvParameterI4uivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramEnvParameterI4uivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameterI4uivNV( params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramEnvParameters4fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramEnvParameters4fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParameters4fvEXT( params->target, params->index, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramEnvParametersI4ivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramEnvParametersI4ivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParametersI4ivNV( params->target, params->index, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramEnvParametersI4uivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramEnvParametersI4uivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramEnvParametersI4uivNV( params->target, params->index, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramLocalParameter4dARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLdouble x;
        GLdouble y;
        GLdouble z;
        GLdouble w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramLocalParameter4dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameter4dARB( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramLocalParameter4dvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramLocalParameter4dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameter4dvARB( params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramLocalParameter4fARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLfloat x;
        GLfloat y;
        GLfloat z;
        GLfloat w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramLocalParameter4fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameter4fARB( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramLocalParameter4fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramLocalParameter4fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameter4fvARB( params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramLocalParameterI4iNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLint x;
        GLint y;
        GLint z;
        GLint w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramLocalParameterI4iNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameterI4iNV( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramLocalParameterI4ivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramLocalParameterI4ivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameterI4ivNV( params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramLocalParameterI4uiNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLuint x;
        GLuint y;
        GLuint z;
        GLuint w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramLocalParameterI4uiNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameterI4uiNV( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramLocalParameterI4uivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramLocalParameterI4uivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameterI4uivNV( params->target, params->index, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramLocalParameters4fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramLocalParameters4fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParameters4fvEXT( params->target, params->index, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramLocalParametersI4ivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramLocalParametersI4ivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParametersI4ivNV( params->target, params->index, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramLocalParametersI4uivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramLocalParametersI4uivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramLocalParametersI4uivNV( params->target, params->index, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramNamedParameter4dNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLsizei len;
        PTR32 name;
        GLdouble x;
        GLdouble y;
        GLdouble z;
        GLdouble w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramNamedParameter4dNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramNamedParameter4dNV( params->id, params->len, ULongToPtr(params->name), params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramNamedParameter4dvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLsizei len;
        PTR32 name;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramNamedParameter4dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramNamedParameter4dvNV( params->id, params->len, ULongToPtr(params->name), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramNamedParameter4fNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLsizei len;
        PTR32 name;
        GLfloat x;
        GLfloat y;
        GLfloat z;
        GLfloat w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramNamedParameter4fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramNamedParameter4fNV( params->id, params->len, ULongToPtr(params->name), params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramNamedParameter4fvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLsizei len;
        PTR32 name;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramNamedParameter4fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramNamedParameter4fvNV( params->id, params->len, ULongToPtr(params->name), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramParameter4dNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLdouble x;
        GLdouble y;
        GLdouble z;
        GLdouble w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramParameter4dNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameter4dNV( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramParameter4dvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramParameter4dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameter4dvNV( params->target, params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramParameter4fNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLfloat x;
        GLfloat y;
        GLfloat z;
        GLfloat w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramParameter4fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameter4fNV( params->target, params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramParameter4fvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramParameter4fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameter4fvNV( params->target, params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramParameteri( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum pname;
        GLint value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramParameteri) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameteri( params->program, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramParameteriARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum pname;
        GLint value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramParameteriARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameteriARB( params->program, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramParameteriEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLenum pname;
        GLint value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramParameteriEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameteriEXT( params->program, params->pname, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramParameters4dvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramParameters4dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameters4dvNV( params->target, params->index, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramParameters4fvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint index;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramParameters4fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramParameters4fvNV( params->target, params->index, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramPathFragmentInputGenNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLenum genMode;
        GLint components;
        PTR32 coeffs;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramPathFragmentInputGenNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramPathFragmentInputGenNV( params->program, params->location, params->genMode, params->components, ULongToPtr(params->coeffs) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramStringARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum format;
        GLsizei len;
        PTR32 string;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramStringARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramStringARB( params->target, params->format, params->len, ULongToPtr(params->string) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramSubroutineParametersuivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei count;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramSubroutineParametersuivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramSubroutineParametersuivNV( params->target, params->count, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1d( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLdouble v0;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1d( params->program, params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1dEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLdouble x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1dEXT( params->program, params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1dv( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1dvEXT( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1f( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLfloat v0;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1f( params->program, params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1fEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLfloat v0;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1fEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1fEXT( params->program, params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1fv( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1fvEXT( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1i( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint v0;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1i( params->program, params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1i64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint64 x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1i64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1i64ARB( params->program, params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1i64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint64EXT x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1i64NV( params->program, params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1i64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1i64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1i64vARB( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1i64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1i64vNV( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1iEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint v0;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1iEXT( params->program, params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1iv( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1ivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1ivEXT( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint v0;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1ui( params->program, params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1ui64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint64 x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1ui64ARB( params->program, params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1ui64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint64EXT x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1ui64NV( params->program, params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1ui64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1ui64vARB( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1ui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1ui64vNV( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1uiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint v0;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1uiEXT( params->program, params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1uiv( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform1uivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform1uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform1uivEXT( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2d( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLdouble v0;
        GLdouble v1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2d( params->program, params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2dEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLdouble x;
        GLdouble y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2dEXT( params->program, params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2dv( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2dvEXT( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2f( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLfloat v0;
        GLfloat v1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2f( params->program, params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2fEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLfloat v0;
        GLfloat v1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2fEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2fEXT( params->program, params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2fv( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2fvEXT( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2i( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint v0;
        GLint v1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2i( params->program, params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2i64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint64 x;
        GLint64 y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2i64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2i64ARB( params->program, params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2i64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint64EXT x;
        GLint64EXT y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2i64NV( params->program, params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2i64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2i64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2i64vARB( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2i64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2i64vNV( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2iEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint v0;
        GLint v1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2iEXT( params->program, params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2iv( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2ivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2ivEXT( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint v0;
        GLuint v1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2ui( params->program, params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2ui64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint64 x;
        GLuint64 y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2ui64ARB( params->program, params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2ui64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint64EXT x;
        GLuint64EXT y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2ui64NV( params->program, params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2ui64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2ui64vARB( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2ui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2ui64vNV( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2uiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint v0;
        GLuint v1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2uiEXT( params->program, params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2uiv( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform2uivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform2uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform2uivEXT( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3d( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLdouble v0;
        GLdouble v1;
        GLdouble v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3d( params->program, params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3dEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3dEXT( params->program, params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3dv( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3dvEXT( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3f( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLfloat v0;
        GLfloat v1;
        GLfloat v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3f( params->program, params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3fEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLfloat v0;
        GLfloat v1;
        GLfloat v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3fEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3fEXT( params->program, params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3fv( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3fvEXT( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3i( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint v0;
        GLint v1;
        GLint v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3i( params->program, params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3i64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint64 x;
        GLint64 y;
        GLint64 z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3i64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3i64ARB( params->program, params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3i64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint64EXT x;
        GLint64EXT y;
        GLint64EXT z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3i64NV( params->program, params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3i64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3i64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3i64vARB( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3i64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3i64vNV( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3iEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint v0;
        GLint v1;
        GLint v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3iEXT( params->program, params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3iv( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3ivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3ivEXT( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint v0;
        GLuint v1;
        GLuint v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3ui( params->program, params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3ui64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint64 x;
        GLuint64 y;
        GLuint64 z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3ui64ARB( params->program, params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3ui64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint64EXT x;
        GLuint64EXT y;
        GLuint64EXT z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3ui64NV( params->program, params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3ui64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3ui64vARB( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3ui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3ui64vNV( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3uiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint v0;
        GLuint v1;
        GLuint v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3uiEXT( params->program, params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3uiv( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform3uivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform3uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform3uivEXT( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4d( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLdouble v0;
        GLdouble v1;
        GLdouble v2;
        GLdouble v3;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4d( params->program, params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4dEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLdouble x;
        GLdouble y;
        GLdouble z;
        GLdouble w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4dEXT( params->program, params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4dv( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4dvEXT( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4f( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLfloat v0;
        GLfloat v1;
        GLfloat v2;
        GLfloat v3;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4f( params->program, params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4fEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLfloat v0;
        GLfloat v1;
        GLfloat v2;
        GLfloat v3;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4fEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4fEXT( params->program, params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4fv( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4fvEXT( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4i( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint v0;
        GLint v1;
        GLint v2;
        GLint v3;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4i( params->program, params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4i64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint64 x;
        GLint64 y;
        GLint64 z;
        GLint64 w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4i64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4i64ARB( params->program, params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4i64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint64EXT x;
        GLint64EXT y;
        GLint64EXT z;
        GLint64EXT w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4i64NV( params->program, params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4i64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4i64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4i64vARB( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4i64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4i64vNV( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4iEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLint v0;
        GLint v1;
        GLint v2;
        GLint v3;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4iEXT( params->program, params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4iv( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4ivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4ivEXT( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint v0;
        GLuint v1;
        GLuint v2;
        GLuint v3;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4ui( params->program, params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4ui64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint64 x;
        GLuint64 y;
        GLuint64 z;
        GLuint64 w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4ui64ARB( params->program, params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4ui64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint64EXT x;
        GLuint64EXT y;
        GLuint64EXT z;
        GLuint64EXT w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4ui64NV( params->program, params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4ui64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4ui64vARB( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4ui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4ui64vNV( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4uiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint v0;
        GLuint v1;
        GLuint v2;
        GLuint v3;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4uiEXT( params->program, params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4uiv( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniform4uivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniform4uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniform4uivEXT( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformHandleui64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint64 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformHandleui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformHandleui64ARB( params->program, params->location, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformHandleui64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint64 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformHandleui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformHandleui64NV( params->program, params->location, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformHandleui64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformHandleui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformHandleui64vARB( params->program, params->location, params->count, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformHandleui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformHandleui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformHandleui64vNV( params->program, params->location, params->count, ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix2dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2dv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix2dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2dvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix2fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2fv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix2fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2fvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix2x3dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2x3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2x3dv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix2x3dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2x3dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2x3dvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix2x3fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2x3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2x3fv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix2x3fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2x3fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2x3fvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix2x4dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2x4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2x4dv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix2x4dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2x4dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2x4dvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix2x4fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2x4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2x4fv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix2x4fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix2x4fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix2x4fvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix3dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3dv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix3dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3dvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix3fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3fv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix3fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3fvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix3x2dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3x2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3x2dv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix3x2dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3x2dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3x2dvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix3x2fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3x2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3x2fv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix3x2fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3x2fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3x2fvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix3x4dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3x4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3x4dv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix3x4dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3x4dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3x4dvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix3x4fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3x4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3x4fv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix3x4fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix3x4fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix3x4fvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix4dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4dv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix4dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4dvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix4fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4fv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix4fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4fvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix4x2dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4x2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4x2dv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix4x2dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4x2dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4x2dvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix4x2fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4x2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4x2fv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix4x2fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4x2fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4x2fvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix4x3dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4x3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4x3dv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix4x3dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4x3dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4x3dvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix4x3fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4x3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4x3fv( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformMatrix4x3fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformMatrix4x3fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformMatrix4x3fvEXT( params->program, params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformui64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint64EXT value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformui64NV( params->program, params->location, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramUniformui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramUniformui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramUniformui64vNV( params->program, params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProgramVertexLimitNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint limit;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProgramVertexLimitNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProgramVertexLimitNV( params->target, params->limit );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProvokingVertex( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProvokingVertex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProvokingVertex( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glProvokingVertexEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glProvokingVertexEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glProvokingVertexEXT( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPushClientAttribDefaultEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLbitfield mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPushClientAttribDefaultEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPushClientAttribDefaultEXT( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPushDebugGroup( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum source;
        GLuint id;
        GLsizei length;
        PTR32 message;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPushDebugGroup) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPushDebugGroup( params->source, params->id, params->length, ULongToPtr(params->message) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glPushGroupMarkerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei length;
        PTR32 marker;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glPushGroupMarkerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glPushGroupMarkerEXT( params->length, ULongToPtr(params->marker) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glQueryCounter( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum target;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glQueryCounter) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glQueryCounter( params->id, params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glQueryMatrixxOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 mantissa;
        PTR32 exponent;
        GLbitfield ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glQueryMatrixxOES) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glQueryMatrixxOES( ULongToPtr(params->mantissa), ULongToPtr(params->exponent) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glQueryObjectParameteruiAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint id;
        GLenum pname;
        GLuint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glQueryObjectParameteruiAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glQueryObjectParameteruiAMD( params->target, params->id, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glQueryResourceNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum queryType;
        GLint tagId;
        GLuint count;
        PTR32 buffer;
        GLint ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glQueryResourceNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glQueryResourceNV( params->queryType, params->tagId, params->count, ULongToPtr(params->buffer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glQueryResourceTagNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint tagId;
        PTR32 tagString;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glQueryResourceTagNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glQueryResourceTagNV( params->tagId, ULongToPtr(params->tagString) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRasterPos2xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed x;
        GLfixed y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos2xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2xOES( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRasterPos2xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos2xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos2xvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRasterPos3xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed x;
        GLfixed y;
        GLfixed z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos3xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3xOES( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRasterPos3xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos3xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos3xvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRasterPos4xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed x;
        GLfixed y;
        GLfixed z;
        GLfixed w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos4xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4xOES( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRasterPos4xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterPos4xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterPos4xvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRasterSamplesEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint samples;
        GLboolean fixedsamplelocations;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRasterSamplesEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRasterSamplesEXT( params->samples, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReadBufferRegion( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum region;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReadBufferRegion) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReadBufferRegion( params->region, params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReadInstrumentsSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLint marker;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReadInstrumentsSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReadInstrumentsSGIX( params->marker );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReadnPixels( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLenum type;
        GLsizei bufSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReadnPixels) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReadnPixels( params->x, params->y, params->width, params->height, params->format, params->type, params->bufSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReadnPixelsARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLenum type;
        GLsizei bufSize;
        PTR32 data;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReadnPixelsARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReadnPixelsARB( params->x, params->y, params->width, params->height, params->format, params->type, params->bufSize, ULongToPtr(params->data) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRectxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed x1;
        GLfixed y1;
        GLfixed x2;
        GLfixed y2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRectxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRectxOES( params->x1, params->y1, params->x2, params->y2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRectxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v1;
        PTR32 v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRectxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRectxvOES( ULongToPtr(params->v1), ULongToPtr(params->v2) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReferencePlaneSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 equation;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReferencePlaneSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReferencePlaneSGIX( ULongToPtr(params->equation) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReleaseKeyedMutexWin32EXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint memory;
        GLuint64 key;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReleaseKeyedMutexWin32EXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glReleaseKeyedMutexWin32EXT( params->memory, params->key );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReleaseShaderCompiler( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReleaseShaderCompiler) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReleaseShaderCompiler();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRenderGpuMaskNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLbitfield mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRenderGpuMaskNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRenderGpuMaskNV( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRenderbufferStorage( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRenderbufferStorage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRenderbufferStorage( params->target, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRenderbufferStorageEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRenderbufferStorageEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRenderbufferStorageEXT( params->target, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRenderbufferStorageMultisample( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei samples;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRenderbufferStorageMultisample) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRenderbufferStorageMultisample( params->target, params->samples, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRenderbufferStorageMultisampleAdvancedAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei samples;
        GLsizei storageSamples;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRenderbufferStorageMultisampleAdvancedAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRenderbufferStorageMultisampleAdvancedAMD( params->target, params->samples, params->storageSamples, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRenderbufferStorageMultisampleCoverageNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei coverageSamples;
        GLsizei colorSamples;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRenderbufferStorageMultisampleCoverageNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRenderbufferStorageMultisampleCoverageNV( params->target, params->coverageSamples, params->colorSamples, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRenderbufferStorageMultisampleEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei samples;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRenderbufferStorageMultisampleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRenderbufferStorageMultisampleEXT( params->target, params->samples, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodePointerSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glReplacementCodeubSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLubyte code;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeubSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeubSUN( params->code );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeubvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 code;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeubvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeubvSUN( ULongToPtr(params->code) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiColor3fVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint rc;
        GLfloat r;
        GLfloat g;
        GLfloat b;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiColor3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiColor3fVertex3fSUN( params->rc, params->r, params->g, params->b, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiColor3fVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 rc;
        PTR32 c;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiColor3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiColor3fVertex3fvSUN( ULongToPtr(params->rc), ULongToPtr(params->c), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiColor4fNormal3fVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint rc;
        GLfloat r;
        GLfloat g;
        GLfloat b;
        GLfloat a;
        GLfloat nx;
        GLfloat ny;
        GLfloat nz;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiColor4fNormal3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiColor4fNormal3fVertex3fSUN( params->rc, params->r, params->g, params->b, params->a, params->nx, params->ny, params->nz, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiColor4fNormal3fVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 rc;
        PTR32 c;
        PTR32 n;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiColor4fNormal3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiColor4fNormal3fVertex3fvSUN( ULongToPtr(params->rc), ULongToPtr(params->c), ULongToPtr(params->n), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiColor4ubVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint rc;
        GLubyte r;
        GLubyte g;
        GLubyte b;
        GLubyte a;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiColor4ubVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiColor4ubVertex3fSUN( params->rc, params->r, params->g, params->b, params->a, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiColor4ubVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 rc;
        PTR32 c;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiColor4ubVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiColor4ubVertex3fvSUN( ULongToPtr(params->rc), ULongToPtr(params->c), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiNormal3fVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint rc;
        GLfloat nx;
        GLfloat ny;
        GLfloat nz;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiNormal3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiNormal3fVertex3fSUN( params->rc, params->nx, params->ny, params->nz, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiNormal3fVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 rc;
        PTR32 n;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiNormal3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiNormal3fVertex3fvSUN( ULongToPtr(params->rc), ULongToPtr(params->n), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint code;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiSUN( params->code );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        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;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN( params->rc, params->s, params->t, params->r, params->g, params->b, params->a, params->nx, params->ny, params->nz, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 rc;
        PTR32 tc;
        PTR32 c;
        PTR32 n;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN( ULongToPtr(params->rc), ULongToPtr(params->tc), ULongToPtr(params->c), ULongToPtr(params->n), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint rc;
        GLfloat s;
        GLfloat t;
        GLfloat nx;
        GLfloat ny;
        GLfloat nz;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN( params->rc, params->s, params->t, params->nx, params->ny, params->nz, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 rc;
        PTR32 tc;
        PTR32 n;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN( ULongToPtr(params->rc), ULongToPtr(params->tc), ULongToPtr(params->n), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiTexCoord2fVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint rc;
        GLfloat s;
        GLfloat t;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiTexCoord2fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiTexCoord2fVertex3fSUN( params->rc, params->s, params->t, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiTexCoord2fVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 rc;
        PTR32 tc;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiTexCoord2fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiTexCoord2fVertex3fvSUN( ULongToPtr(params->rc), ULongToPtr(params->tc), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint rc;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiVertex3fSUN( params->rc, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuiVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 rc;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuiVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuiVertex3fvSUN( ULongToPtr(params->rc), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeuivSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 code;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeuivSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeuivSUN( ULongToPtr(params->code) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeusSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLushort code;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeusSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeusSUN( params->code );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glReplacementCodeusvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 code;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glReplacementCodeusvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glReplacementCodeusvSUN( ULongToPtr(params->code) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRequestResidentProgramsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei n;
        PTR32 programs;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRequestResidentProgramsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRequestResidentProgramsNV( params->n, ULongToPtr(params->programs) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glResetHistogram( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glResetHistogram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResetHistogram( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glResetHistogramEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glResetHistogramEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResetHistogramEXT( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glResetMemoryObjectParameterNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint memory;
        GLenum pname;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glResetMemoryObjectParameterNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResetMemoryObjectParameterNV( params->memory, params->pname );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glResetMinmax( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glResetMinmax) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResetMinmax( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glResetMinmaxEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glResetMinmaxEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResetMinmaxEXT( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glResizeBuffersMESA( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glResizeBuffersMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResizeBuffersMESA();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glResolveDepthValuesNV( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glResolveDepthValuesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResolveDepthValuesNV();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glResumeTransformFeedback( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glResumeTransformFeedback) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResumeTransformFeedback();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glResumeTransformFeedbackNV( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glResumeTransformFeedbackNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glResumeTransformFeedbackNV();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRotatex( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed angle;
        GLfixed x;
        GLfixed y;
        GLfixed z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRotatex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRotatex( params->angle, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glRotatexOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed angle;
        GLfixed x;
        GLfixed y;
        GLfixed z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glRotatexOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glRotatexOES( params->angle, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSampleCoverage( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat value;
        GLboolean invert;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSampleCoverage) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSampleCoverage( params->value, params->invert );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSampleCoverageARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat value;
        GLboolean invert;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSampleCoverageARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSampleCoverageARB( params->value, params->invert );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSampleCoveragex( void *args )
{
    struct
    {
        PTR32 teb;
        GLclampx value;
        GLboolean invert;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSampleCoveragex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSampleCoveragex( params->value, params->invert );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSampleMapATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint dst;
        GLuint interp;
        GLenum swizzle;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSampleMapATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSampleMapATI( params->dst, params->interp, params->swizzle );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSampleMaskEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLclampf value;
        GLboolean invert;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSampleMaskEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSampleMaskEXT( params->value, params->invert );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSampleMaskIndexedNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLbitfield mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSampleMaskIndexedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSampleMaskIndexedNV( params->index, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSampleMaskSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLclampf value;
        GLboolean invert;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSampleMaskSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSampleMaskSGIS( params->value, params->invert );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSampleMaski( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint maskNumber;
        GLbitfield mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSampleMaski) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSampleMaski( params->maskNumber, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSamplePatternEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pattern;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSamplePatternEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSamplePatternEXT( params->pattern );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSamplePatternSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pattern;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSamplePatternSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSamplePatternSGIS( params->pattern );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSamplerParameterIiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint sampler;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSamplerParameterIiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSamplerParameterIiv( params->sampler, params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSamplerParameterIuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint sampler;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSamplerParameterIuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSamplerParameterIuiv( params->sampler, params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSamplerParameterf( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint sampler;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSamplerParameterf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSamplerParameterf( params->sampler, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSamplerParameterfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint sampler;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSamplerParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSamplerParameterfv( params->sampler, params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSamplerParameteri( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint sampler;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSamplerParameteri) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSamplerParameteri( params->sampler, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSamplerParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint sampler;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSamplerParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSamplerParameteriv( params->sampler, params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glScalex( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed x;
        GLfixed y;
        GLfixed z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glScalex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScalex( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glScalexOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed x;
        GLfixed y;
        GLfixed z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glScalexOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScalexOES( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glScissorArrayv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint first;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glScissorArrayv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScissorArrayv( params->first, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glScissorExclusiveArrayvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint first;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glScissorExclusiveArrayvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScissorExclusiveArrayvNV( params->first, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glScissorExclusiveNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glScissorExclusiveNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScissorExclusiveNV( params->x, params->y, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glScissorIndexed( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint left;
        GLint bottom;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glScissorIndexed) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScissorIndexed( params->index, params->left, params->bottom, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glScissorIndexedv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glScissorIndexedv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glScissorIndexedv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3b( void *args )
{
    struct
    {
        PTR32 teb;
        GLbyte red;
        GLbyte green;
        GLbyte blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3b) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3b( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3bEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLbyte red;
        GLbyte green;
        GLbyte blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3bEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3bEXT( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3bv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3bv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3bv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3bvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3bvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3bvEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble red;
        GLdouble green;
        GLdouble blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3d( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3dEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble red;
        GLdouble green;
        GLdouble blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3dEXT( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3dv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3dvEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat red;
        GLfloat green;
        GLfloat blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3f( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3fEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat red;
        GLfloat green;
        GLfloat blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3fEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3fEXT( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3fv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3fvEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLhalfNV red;
        GLhalfNV green;
        GLhalfNV blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3hNV( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3hvNV( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint red;
        GLint green;
        GLint blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3i( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3iEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint red;
        GLint green;
        GLint blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3iEXT( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3iv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3iv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3ivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3ivEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3s( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort red;
        GLshort green;
        GLshort blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3s( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3sEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort red;
        GLshort green;
        GLshort blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3sEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3sEXT( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3sv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3sv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3svEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3svEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3svEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3ub( void *args )
{
    struct
    {
        PTR32 teb;
        GLubyte red;
        GLubyte green;
        GLubyte blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3ub) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3ub( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3ubEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLubyte red;
        GLubyte green;
        GLubyte blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3ubEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3ubEXT( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3ubv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3ubv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3ubv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3ubvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3ubvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3ubvEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint red;
        GLuint green;
        GLuint blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3ui( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3uiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint red;
        GLuint green;
        GLuint blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3uiEXT( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3uiv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3uiv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3uivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3uivEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3us( void *args )
{
    struct
    {
        PTR32 teb;
        GLushort red;
        GLushort green;
        GLushort blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3us) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3us( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3usEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLushort red;
        GLushort green;
        GLushort blue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3usEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3usEXT( params->red, params->green, params->blue );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3usv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3usv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3usv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColor3usvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColor3usvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColor3usvEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColorFormatNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColorFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColorFormatNV( params->size, params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColorP3ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLuint color;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColorP3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColorP3ui( params->type, params->color );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColorP3uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        PTR32 color;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColorP3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColorP3uiv( params->type, ULongToPtr(params->color) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColorPointer( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColorPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColorPointer( params->size, params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColorPointerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSecondaryColorPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSecondaryColorPointerEXT( params->size, params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSecondaryColorPointerListIBM( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLint stride;
        PTR32 pointer;
        GLint ptrstride;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glSelectPerfMonitorCountersAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint monitor;
        GLboolean enable;
        GLuint group;
        GLint numCounters;
        PTR32 counterList;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSelectPerfMonitorCountersAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSelectPerfMonitorCountersAMD( params->monitor, params->enable, params->group, params->numCounters, ULongToPtr(params->counterList) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSelectTextureCoordSetSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSelectTextureCoordSetSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSelectTextureCoordSetSGIS( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSelectTextureSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSelectTextureSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSelectTextureSGIS( params->target );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSemaphoreParameterivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint semaphore;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSemaphoreParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSemaphoreParameterivNV( params->semaphore, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSemaphoreParameterui64vEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint semaphore;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSemaphoreParameterui64vEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSemaphoreParameterui64vEXT( params->semaphore, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSeparableFilter2D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLenum type;
        PTR32 row;
        PTR32 column;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSeparableFilter2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSeparableFilter2D( params->target, params->internalformat, params->width, params->height, params->format, params->type, ULongToPtr(params->row), ULongToPtr(params->column) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSeparableFilter2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLenum type;
        PTR32 row;
        PTR32 column;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSeparableFilter2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSeparableFilter2DEXT( params->target, params->internalformat, params->width, params->height, params->format, params->type, ULongToPtr(params->row), ULongToPtr(params->column) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSetFenceAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint fence;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSetFenceAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSetFenceAPPLE( params->fence );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSetFenceNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint fence;
        GLenum condition;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSetFenceNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSetFenceNV( params->fence, params->condition );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSetFragmentShaderConstantATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint dst;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSetFragmentShaderConstantATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSetFragmentShaderConstantATI( params->dst, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSetInvariantEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum type;
        PTR32 addr;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSetInvariantEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSetInvariantEXT( params->id, params->type, ULongToPtr(params->addr) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSetLocalConstantEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum type;
        PTR32 addr;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSetLocalConstantEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSetLocalConstantEXT( params->id, params->type, ULongToPtr(params->addr) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSetMultisamplefvAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLuint index;
        PTR32 val;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSetMultisamplefvAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSetMultisamplefvAMD( params->pname, params->index, ULongToPtr(params->val) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glShaderBinary( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei count;
        PTR32 shaders;
        GLenum binaryFormat;
        PTR32 binary;
        GLsizei length;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glShaderBinary) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShaderBinary( params->count, ULongToPtr(params->shaders), params->binaryFormat, ULongToPtr(params->binary), params->length );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glShaderOp1EXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum op;
        GLuint res;
        GLuint arg1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glShaderOp1EXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShaderOp1EXT( params->op, params->res, params->arg1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glShaderOp2EXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum op;
        GLuint res;
        GLuint arg1;
        GLuint arg2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glShaderOp2EXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShaderOp2EXT( params->op, params->res, params->arg1, params->arg2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glShaderOp3EXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum op;
        GLuint res;
        GLuint arg1;
        GLuint arg2;
        GLuint arg3;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glShaderOp3EXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShaderOp3EXT( params->op, params->res, params->arg1, params->arg2, params->arg3 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glShaderSource( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint shader;
        GLsizei count;
        PTR32 string;
        PTR32 length;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const GLchar **string;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glShaderSource) return STATUS_NOT_IMPLEMENTED;
    string = copy_wow64_ptr32s( params->string, params->count );
    funcs->p_glShaderSource( params->shader, params->count, string, ULongToPtr(params->length) );
    free( string );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glShaderSourceARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB shaderObj;
        GLsizei count;
        PTR32 string;
        PTR32 length;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const GLcharARB **string;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glShaderSourceARB) return STATUS_NOT_IMPLEMENTED;
    string = copy_wow64_ptr32s( params->string, params->count );
    funcs->p_glShaderSourceARB( params->shaderObj, params->count, string, ULongToPtr(params->length) );
    free( string );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glShaderStorageBlockBinding( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint storageBlockIndex;
        GLuint storageBlockBinding;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glShaderStorageBlockBinding) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShaderStorageBlockBinding( params->program, params->storageBlockIndex, params->storageBlockBinding );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glShadingRateCombinerOpsEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum combinerOp0;
        GLenum combinerOp1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glShadingRateCombinerOpsEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShadingRateCombinerOpsEXT( params->combinerOp0, params->combinerOp1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glShadingRateEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum rate;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glShadingRateEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShadingRateEXT( params->rate );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glShadingRateImageBarrierNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLboolean synchronize;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glShadingRateImageBarrierNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShadingRateImageBarrierNV( params->synchronize );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glShadingRateImagePaletteNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint viewport;
        GLuint first;
        GLsizei count;
        PTR32 rates;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glShadingRateImagePaletteNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShadingRateImagePaletteNV( params->viewport, params->first, params->count, ULongToPtr(params->rates) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glShadingRateSampleOrderCustomNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum rate;
        GLuint samples;
        PTR32 locations;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glShadingRateSampleOrderCustomNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShadingRateSampleOrderCustomNV( params->rate, params->samples, ULongToPtr(params->locations) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glShadingRateSampleOrderNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum order;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glShadingRateSampleOrderNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glShadingRateSampleOrderNV( params->order );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSharpenTexFuncSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei n;
        PTR32 points;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSharpenTexFuncSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSharpenTexFuncSGIS( params->target, params->n, ULongToPtr(params->points) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSignalSemaphoreEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint semaphore;
        GLuint numBufferBarriers;
        PTR32 buffers;
        GLuint numTextureBarriers;
        PTR32 textures;
        PTR32 dstLayouts;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSignalSemaphoreEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSignalSemaphoreEXT( params->semaphore, params->numBufferBarriers, ULongToPtr(params->buffers), params->numTextureBarriers, ULongToPtr(params->textures), ULongToPtr(params->dstLayouts) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSignalSemaphoreui64NVX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint signalGpu;
        GLsizei fenceObjectCount;
        PTR32 semaphoreArray;
        PTR32 fenceValueArray;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSignalSemaphoreui64NVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSignalSemaphoreui64NVX( params->signalGpu, params->fenceObjectCount, ULongToPtr(params->semaphoreArray), ULongToPtr(params->fenceValueArray) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSignalVkFenceNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint64 vkFence;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSignalVkFenceNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSignalVkFenceNV( params->vkFence );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSignalVkSemaphoreNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint64 vkSemaphore;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSignalVkSemaphoreNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSignalVkSemaphoreNV( params->vkSemaphore );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSpecializeShader( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint shader;
        PTR32 pEntryPoint;
        GLuint numSpecializationConstants;
        PTR32 pConstantIndex;
        PTR32 pConstantValue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSpecializeShader) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSpecializeShader( params->shader, ULongToPtr(params->pEntryPoint), params->numSpecializationConstants, ULongToPtr(params->pConstantIndex), ULongToPtr(params->pConstantValue) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSpecializeShaderARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint shader;
        PTR32 pEntryPoint;
        GLuint numSpecializationConstants;
        PTR32 pConstantIndex;
        PTR32 pConstantValue;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSpecializeShaderARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSpecializeShaderARB( params->shader, ULongToPtr(params->pEntryPoint), params->numSpecializationConstants, ULongToPtr(params->pConstantIndex), ULongToPtr(params->pConstantValue) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSpriteParameterfSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSpriteParameterfSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSpriteParameterfSGIX( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSpriteParameterfvSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSpriteParameterfvSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSpriteParameterfvSGIX( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSpriteParameteriSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSpriteParameteriSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSpriteParameteriSGIX( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSpriteParameterivSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSpriteParameterivSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSpriteParameterivSGIX( params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStartInstrumentsSGIX( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStartInstrumentsSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStartInstrumentsSGIX();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStateCaptureNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint state;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStateCaptureNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStateCaptureNV( params->state, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStencilClearTagEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei stencilTagBits;
        GLuint stencilClearTag;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilClearTagEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilClearTagEXT( params->stencilTagBits, params->stencilClearTag );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStencilFillPathInstancedNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei numPaths;
        GLenum pathNameType;
        PTR32 paths;
        GLuint pathBase;
        GLenum fillMode;
        GLuint mask;
        GLenum transformType;
        PTR32 transformValues;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilFillPathInstancedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilFillPathInstancedNV( params->numPaths, params->pathNameType, ULongToPtr(params->paths), params->pathBase, params->fillMode, params->mask, params->transformType, ULongToPtr(params->transformValues) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStencilFillPathNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLenum fillMode;
        GLuint mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilFillPathNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilFillPathNV( params->path, params->fillMode, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStencilFuncSeparate( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum func;
        GLint ref;
        GLuint mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilFuncSeparate) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilFuncSeparate( params->face, params->func, params->ref, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStencilFuncSeparateATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum frontfunc;
        GLenum backfunc;
        GLint ref;
        GLuint mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilFuncSeparateATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilFuncSeparateATI( params->frontfunc, params->backfunc, params->ref, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStencilMaskSeparate( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLuint mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilMaskSeparate) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilMaskSeparate( params->face, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStencilOpSeparate( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum sfail;
        GLenum dpfail;
        GLenum dppass;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilOpSeparate) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilOpSeparate( params->face, params->sfail, params->dpfail, params->dppass );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStencilOpSeparateATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum sfail;
        GLenum dpfail;
        GLenum dppass;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilOpSeparateATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilOpSeparateATI( params->face, params->sfail, params->dpfail, params->dppass );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStencilOpValueAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLuint value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilOpValueAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilOpValueAMD( params->face, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStencilStrokePathInstancedNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei numPaths;
        GLenum pathNameType;
        PTR32 paths;
        GLuint pathBase;
        GLint reference;
        GLuint mask;
        GLenum transformType;
        PTR32 transformValues;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilStrokePathInstancedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilStrokePathInstancedNV( params->numPaths, params->pathNameType, ULongToPtr(params->paths), params->pathBase, params->reference, params->mask, params->transformType, ULongToPtr(params->transformValues) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStencilStrokePathNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLint reference;
        GLuint mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilStrokePathNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilStrokePathNV( params->path, params->reference, params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStencilThenCoverFillPathInstancedNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei numPaths;
        GLenum pathNameType;
        PTR32 paths;
        GLuint pathBase;
        GLenum fillMode;
        GLuint mask;
        GLenum coverMode;
        GLenum transformType;
        PTR32 transformValues;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilThenCoverFillPathInstancedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilThenCoverFillPathInstancedNV( params->numPaths, params->pathNameType, ULongToPtr(params->paths), params->pathBase, params->fillMode, params->mask, params->coverMode, params->transformType, ULongToPtr(params->transformValues) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStencilThenCoverFillPathNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLenum fillMode;
        GLuint mask;
        GLenum coverMode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilThenCoverFillPathNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilThenCoverFillPathNV( params->path, params->fillMode, params->mask, params->coverMode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStencilThenCoverStrokePathInstancedNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei numPaths;
        GLenum pathNameType;
        PTR32 paths;
        GLuint pathBase;
        GLint reference;
        GLuint mask;
        GLenum coverMode;
        GLenum transformType;
        PTR32 transformValues;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilThenCoverStrokePathInstancedNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilThenCoverStrokePathInstancedNV( params->numPaths, params->pathNameType, ULongToPtr(params->paths), params->pathBase, params->reference, params->mask, params->coverMode, params->transformType, ULongToPtr(params->transformValues) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStencilThenCoverStrokePathNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint path;
        GLint reference;
        GLuint mask;
        GLenum coverMode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStencilThenCoverStrokePathNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStencilThenCoverStrokePathNV( params->path, params->reference, params->mask, params->coverMode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStopInstrumentsSGIX( void *args )
{
    struct
    {
        PTR32 teb;
        GLint marker;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStopInstrumentsSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStopInstrumentsSGIX( params->marker );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glStringMarkerGREMEDY( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei len;
        PTR32 string;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glStringMarkerGREMEDY) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glStringMarkerGREMEDY( params->len, ULongToPtr(params->string) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSubpixelPrecisionBiasNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint xbits;
        GLuint ybits;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSubpixelPrecisionBiasNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSubpixelPrecisionBiasNV( params->xbits, params->ybits );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSwizzleEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint res;
        GLuint in;
        GLenum outX;
        GLenum outY;
        GLenum outZ;
        GLenum outW;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSwizzleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSwizzleEXT( params->res, params->in, params->outX, params->outY, params->outZ, params->outW );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glSyncTextureINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glSyncTextureINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glSyncTextureINTEL( params->texture );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTagSampleBufferSGIX( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTagSampleBufferSGIX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTagSampleBufferSGIX();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTangent3bEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLbyte tx;
        GLbyte ty;
        GLbyte tz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTangent3bEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3bEXT( params->tx, params->ty, params->tz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTangent3bvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTangent3bvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3bvEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTangent3dEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble tx;
        GLdouble ty;
        GLdouble tz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTangent3dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3dEXT( params->tx, params->ty, params->tz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTangent3dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTangent3dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3dvEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTangent3fEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat tx;
        GLfloat ty;
        GLfloat tz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTangent3fEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3fEXT( params->tx, params->ty, params->tz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTangent3fvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTangent3fvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3fvEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTangent3iEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint tx;
        GLint ty;
        GLint tz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTangent3iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3iEXT( params->tx, params->ty, params->tz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTangent3ivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTangent3ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3ivEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTangent3sEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort tx;
        GLshort ty;
        GLshort tz;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTangent3sEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3sEXT( params->tx, params->ty, params->tz );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTangent3svEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTangent3svEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangent3svEXT( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTangentPointerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTangentPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTangentPointerEXT( params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTbufferMask3DFX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTbufferMask3DFX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTbufferMask3DFX( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTessellationFactorAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat factor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTessellationFactorAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTessellationFactorAMD( params->factor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTessellationModeAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTessellationModeAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTessellationModeAMD( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTestFenceAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint fence;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTestFenceAPPLE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glTestFenceAPPLE( params->fence );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTestFenceNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint fence;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTestFenceNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glTestFenceNV( params->fence );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTestObjectAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum object;
        GLuint name;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTestObjectAPPLE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glTestObjectAPPLE( params->object, params->name );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexAttachMemoryNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint memory;
        GLuint64 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexAttachMemoryNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexAttachMemoryNV( params->target, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexBuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexBuffer( params->target, params->internalformat, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexBufferARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexBufferARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexBufferARB( params->target, params->internalformat, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexBufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexBufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexBufferEXT( params->target, params->internalformat, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexBufferRange( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalformat;
        GLuint buffer;
        PTR32 offset;
        PTR32 size;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexBufferRange) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexBufferRange( params->target, params->internalformat, params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexBumpParameterfvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexBumpParameterfvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexBumpParameterfvATI( params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexBumpParameterivATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexBumpParameterivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexBumpParameterivATI( params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord1bOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLbyte s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord1bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1bOES( params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord1bvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord1bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1bvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord1hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLhalfNV s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord1hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1hNV( params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord1hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord1hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1hvNV( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord1xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed s;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord1xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1xOES( params->s );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord1xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord1xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord1xvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord2bOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLbyte s;
        GLbyte t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2bOES( params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord2bvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2bvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord2fColor3fVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat s;
        GLfloat t;
        GLfloat r;
        GLfloat g;
        GLfloat b;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2fColor3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fColor3fVertex3fSUN( params->s, params->t, params->r, params->g, params->b, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord2fColor3fVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 tc;
        PTR32 c;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2fColor3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fColor3fVertex3fvSUN( ULongToPtr(params->tc), ULongToPtr(params->c), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord2fColor4fNormal3fVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat s;
        GLfloat t;
        GLfloat r;
        GLfloat g;
        GLfloat b;
        GLfloat a;
        GLfloat nx;
        GLfloat ny;
        GLfloat nz;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2fColor4fNormal3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fColor4fNormal3fVertex3fSUN( params->s, params->t, params->r, params->g, params->b, params->a, params->nx, params->ny, params->nz, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord2fColor4fNormal3fVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 tc;
        PTR32 c;
        PTR32 n;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2fColor4fNormal3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fColor4fNormal3fVertex3fvSUN( ULongToPtr(params->tc), ULongToPtr(params->c), ULongToPtr(params->n), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord2fColor4ubVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat s;
        GLfloat t;
        GLubyte r;
        GLubyte g;
        GLubyte b;
        GLubyte a;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2fColor4ubVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fColor4ubVertex3fSUN( params->s, params->t, params->r, params->g, params->b, params->a, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord2fColor4ubVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 tc;
        PTR32 c;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2fColor4ubVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fColor4ubVertex3fvSUN( ULongToPtr(params->tc), ULongToPtr(params->c), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord2fNormal3fVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat s;
        GLfloat t;
        GLfloat nx;
        GLfloat ny;
        GLfloat nz;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2fNormal3fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fNormal3fVertex3fSUN( params->s, params->t, params->nx, params->ny, params->nz, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord2fNormal3fVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 tc;
        PTR32 n;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2fNormal3fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fNormal3fVertex3fvSUN( ULongToPtr(params->tc), ULongToPtr(params->n), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord2fVertex3fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat s;
        GLfloat t;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2fVertex3fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fVertex3fSUN( params->s, params->t, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord2fVertex3fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 tc;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2fVertex3fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2fVertex3fvSUN( ULongToPtr(params->tc), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord2hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLhalfNV s;
        GLhalfNV t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2hNV( params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord2hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2hvNV( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord2xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed s;
        GLfixed t;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2xOES( params->s, params->t );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord2xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord2xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord2xvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord3bOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLbyte s;
        GLbyte t;
        GLbyte r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord3bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3bOES( params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord3bvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord3bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3bvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord3hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLhalfNV s;
        GLhalfNV t;
        GLhalfNV r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord3hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3hNV( params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord3hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord3hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3hvNV( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord3xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed s;
        GLfixed t;
        GLfixed r;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord3xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3xOES( params->s, params->t, params->r );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord3xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord3xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord3xvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord4bOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLbyte s;
        GLbyte t;
        GLbyte r;
        GLbyte q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4bOES( params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord4bvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4bvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord4fColor4fNormal3fVertex4fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        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;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4fColor4fNormal3fVertex4fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4fColor4fNormal3fVertex4fSUN( params->s, params->t, params->p, params->q, params->r, params->g, params->b, params->a, params->nx, params->ny, params->nz, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord4fColor4fNormal3fVertex4fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 tc;
        PTR32 c;
        PTR32 n;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4fColor4fNormal3fVertex4fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4fColor4fNormal3fVertex4fvSUN( ULongToPtr(params->tc), ULongToPtr(params->c), ULongToPtr(params->n), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord4fVertex4fSUN( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat s;
        GLfloat t;
        GLfloat p;
        GLfloat q;
        GLfloat x;
        GLfloat y;
        GLfloat z;
        GLfloat w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4fVertex4fSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4fVertex4fSUN( params->s, params->t, params->p, params->q, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord4fVertex4fvSUN( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 tc;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4fVertex4fvSUN) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4fVertex4fvSUN( ULongToPtr(params->tc), ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord4hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLhalfNV s;
        GLhalfNV t;
        GLhalfNV r;
        GLhalfNV q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4hNV( params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord4hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4hvNV( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord4xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed s;
        GLfixed t;
        GLfixed r;
        GLfixed q;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4xOES( params->s, params->t, params->r, params->q );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoord4xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoord4xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoord4xvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoordFormatNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoordFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordFormatNV( params->size, params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoordP1ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLuint coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoordP1ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordP1ui( params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoordP1uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoordP1uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordP1uiv( params->type, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoordP2ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLuint coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoordP2ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordP2ui( params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoordP2uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoordP2uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordP2uiv( params->type, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoordP3ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLuint coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoordP3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordP3ui( params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoordP3uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoordP3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordP3uiv( params->type, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoordP4ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLuint coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoordP4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordP4ui( params->type, params->coords );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoordP4uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoordP4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordP4uiv( params->type, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoordPointerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLsizei stride;
        GLsizei count;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexCoordPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexCoordPointerEXT( params->size, params->type, params->stride, params->count, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexCoordPointerListIBM( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLint stride;
        PTR32 pointer;
        GLint ptrstride;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glTexCoordPointervINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        PTR32 pointer;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glTexEnvx( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexEnvx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexEnvx( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexEnvxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexEnvxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexEnvxOES( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexEnvxv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexEnvxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexEnvxv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexEnvxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexEnvxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexEnvxvOES( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexFilterFuncSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum filter;
        GLsizei n;
        PTR32 weights;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexFilterFuncSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexFilterFuncSGIS( params->target, params->filter, params->n, ULongToPtr(params->weights) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexGenxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum coord;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexGenxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexGenxOES( params->coord, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexGenxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum coord;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexGenxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexGenxvOES( params->coord, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexImage2DMultisample( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei samples;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLboolean fixedsamplelocations;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexImage2DMultisample) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage2DMultisample( params->target, params->samples, params->internalformat, params->width, params->height, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexImage2DMultisampleCoverageNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei coverageSamples;
        GLsizei colorSamples;
        GLint internalFormat;
        GLsizei width;
        GLsizei height;
        GLboolean fixedSampleLocations;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexImage2DMultisampleCoverageNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage2DMultisampleCoverageNV( params->target, params->coverageSamples, params->colorSamples, params->internalFormat, params->width, params->height, params->fixedSampleLocations );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexImage3D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLint border;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexImage3D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage3D( params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->border, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexImage3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLint border;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage3DEXT( params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->border, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexImage3DMultisample( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei samples;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLboolean fixedsamplelocations;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexImage3DMultisample) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage3DMultisample( params->target, params->samples, params->internalformat, params->width, params->height, params->depth, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexImage3DMultisampleCoverageNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei coverageSamples;
        GLsizei colorSamples;
        GLint internalFormat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLboolean fixedSampleLocations;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexImage3DMultisampleCoverageNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage3DMultisampleCoverageNV( params->target, params->coverageSamples, params->colorSamples, params->internalFormat, params->width, params->height, params->depth, params->fixedSampleLocations );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexImage4DSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLsizei size4d;
        GLint border;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexImage4DSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexImage4DSGIS( params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->size4d, params->border, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexPageCommitmentARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLboolean commit;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexPageCommitmentARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexPageCommitmentARB( params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexPageCommitmentMemNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint layer;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLuint memory;
        GLuint64 offset;
        GLboolean commit;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexPageCommitmentMemNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexPageCommitmentMemNV( params->target, params->layer, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->memory, params->offset, params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexParameterIiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexParameterIiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterIiv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexParameterIivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexParameterIivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterIivEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexParameterIuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexParameterIuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterIuiv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexParameterIuivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexParameterIuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterIuivEXT( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexParameterx( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexParameterx) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterx( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexParameterxOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        GLfixed param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexParameterxOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterxOES( params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexParameterxv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexParameterxv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterxv( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexParameterxvOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexParameterxvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexParameterxvOES( params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexRenderbufferNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint renderbuffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexRenderbufferNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexRenderbufferNV( params->target, params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexStorage1D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei levels;
        GLenum internalformat;
        GLsizei width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexStorage1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorage1D( params->target, params->levels, params->internalformat, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexStorage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei levels;
        GLenum internalformat;
        GLsizei width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexStorage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorage1DEXT( params->target, params->levels, params->internalformat, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexStorage2D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei levels;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexStorage2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorage2D( params->target, params->levels, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexStorage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei levels;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexStorage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorage2DEXT( params->target, params->levels, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexStorage2DMultisample( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei samples;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLboolean fixedsamplelocations;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexStorage2DMultisample) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorage2DMultisample( params->target, params->samples, params->internalformat, params->width, params->height, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexStorage3D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei levels;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexStorage3D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorage3D( params->target, params->levels, params->internalformat, params->width, params->height, params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexStorage3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei levels;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexStorage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorage3DEXT( params->target, params->levels, params->internalformat, params->width, params->height, params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexStorage3DMultisample( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei samples;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLboolean fixedsamplelocations;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexStorage3DMultisample) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorage3DMultisample( params->target, params->samples, params->internalformat, params->width, params->height, params->depth, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexStorageMem1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei levels;
        GLenum internalFormat;
        GLsizei width;
        GLuint memory;
        GLuint64 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexStorageMem1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorageMem1DEXT( params->target, params->levels, params->internalFormat, params->width, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexStorageMem2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei levels;
        GLenum internalFormat;
        GLsizei width;
        GLsizei height;
        GLuint memory;
        GLuint64 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexStorageMem2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorageMem2DEXT( params->target, params->levels, params->internalFormat, params->width, params->height, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexStorageMem2DMultisampleEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei samples;
        GLenum internalFormat;
        GLsizei width;
        GLsizei height;
        GLboolean fixedSampleLocations;
        GLuint memory;
        GLuint64 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexStorageMem2DMultisampleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorageMem2DMultisampleEXT( params->target, params->samples, params->internalFormat, params->width, params->height, params->fixedSampleLocations, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexStorageMem3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei levels;
        GLenum internalFormat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLuint memory;
        GLuint64 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexStorageMem3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorageMem3DEXT( params->target, params->levels, params->internalFormat, params->width, params->height, params->depth, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexStorageMem3DMultisampleEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei samples;
        GLenum internalFormat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLboolean fixedSampleLocations;
        GLuint memory;
        GLuint64 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexStorageMem3DMultisampleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorageMem3DMultisampleEXT( params->target, params->samples, params->internalFormat, params->width, params->height, params->depth, params->fixedSampleLocations, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexStorageSparseAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLenum internalFormat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLsizei layers;
        GLbitfield flags;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexStorageSparseAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexStorageSparseAMD( params->target, params->internalFormat, params->width, params->height, params->depth, params->layers, params->flags );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexSubImage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLsizei width;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexSubImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexSubImage1DEXT( params->target, params->level, params->xoffset, params->width, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexSubImage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexSubImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexSubImage2DEXT( params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexSubImage3D( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexSubImage3D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexSubImage3D( params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexSubImage3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexSubImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexSubImage3DEXT( params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexSubImage4DSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLint woffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLsizei size4d;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexSubImage4DSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexSubImage4DSGIS( params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->woffset, params->width, params->height, params->depth, params->size4d, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureAttachMemoryNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLuint memory;
        GLuint64 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureAttachMemoryNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureAttachMemoryNV( params->texture, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureBarrier( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureBarrier) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureBarrier();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureBarrierNV( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureBarrierNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureBarrierNV();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum internalformat;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureBuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureBuffer( params->texture, params->internalformat, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureBufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLenum internalformat;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureBufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureBufferEXT( params->texture, params->target, params->internalformat, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureBufferRange( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum internalformat;
        GLuint buffer;
        PTR32 offset;
        PTR32 size;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureBufferRange) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureBufferRange( params->texture, params->internalformat, params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureBufferRangeEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLenum internalformat;
        GLuint buffer;
        PTR32 offset;
        PTR32 size;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureBufferRangeEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureBufferRangeEXT( params->texture, params->target, params->internalformat, params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureColorMaskSGIS( void *args )
{
    struct
    {
        PTR32 teb;
        GLboolean red;
        GLboolean green;
        GLboolean blue;
        GLboolean alpha;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureColorMaskSGIS) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureColorMaskSGIS( params->red, params->green, params->blue, params->alpha );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureImage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLint internalformat;
        GLsizei width;
        GLint border;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureImage1DEXT( params->texture, params->target, params->level, params->internalformat, params->width, params->border, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureImage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLint internalformat;
        GLsizei width;
        GLsizei height;
        GLint border;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureImage2DEXT( params->texture, params->target, params->level, params->internalformat, params->width, params->height, params->border, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureImage2DMultisampleCoverageNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLsizei coverageSamples;
        GLsizei colorSamples;
        GLint internalFormat;
        GLsizei width;
        GLsizei height;
        GLboolean fixedSampleLocations;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureImage2DMultisampleCoverageNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureImage2DMultisampleCoverageNV( params->texture, params->target, params->coverageSamples, params->colorSamples, params->internalFormat, params->width, params->height, params->fixedSampleLocations );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureImage2DMultisampleNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLsizei samples;
        GLint internalFormat;
        GLsizei width;
        GLsizei height;
        GLboolean fixedSampleLocations;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureImage2DMultisampleNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureImage2DMultisampleNV( params->texture, params->target, params->samples, params->internalFormat, params->width, params->height, params->fixedSampleLocations );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureImage3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLint internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLint border;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureImage3DEXT( params->texture, params->target, params->level, params->internalformat, params->width, params->height, params->depth, params->border, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureImage3DMultisampleCoverageNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLsizei coverageSamples;
        GLsizei colorSamples;
        GLint internalFormat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLboolean fixedSampleLocations;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureImage3DMultisampleCoverageNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureImage3DMultisampleCoverageNV( params->texture, params->target, params->coverageSamples, params->colorSamples, params->internalFormat, params->width, params->height, params->depth, params->fixedSampleLocations );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureImage3DMultisampleNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLsizei samples;
        GLint internalFormat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLboolean fixedSampleLocations;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureImage3DMultisampleNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureImage3DMultisampleNV( params->texture, params->target, params->samples, params->internalFormat, params->width, params->height, params->depth, params->fixedSampleLocations );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureLightEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureLightEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureLightEXT( params->pname );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureMaterialEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum face;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureMaterialEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureMaterialEXT( params->face, params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureNormalEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureNormalEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureNormalEXT( params->mode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexturePageCommitmentEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLboolean commit;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexturePageCommitmentEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexturePageCommitmentEXT( params->texture, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTexturePageCommitmentMemNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint layer;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLuint memory;
        GLuint64 offset;
        GLboolean commit;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTexturePageCommitmentMemNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTexturePageCommitmentMemNV( params->texture, params->layer, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->memory, params->offset, params->commit );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureParameterIiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureParameterIiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterIiv( params->texture, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureParameterIivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureParameterIivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterIivEXT( params->texture, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureParameterIuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureParameterIuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterIuiv( params->texture, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureParameterIuivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureParameterIuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterIuivEXT( params->texture, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureParameterf( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureParameterf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterf( params->texture, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureParameterfEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureParameterfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterfEXT( params->texture, params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureParameterfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureParameterfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterfv( params->texture, params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureParameterfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureParameterfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterfvEXT( params->texture, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureParameteri( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureParameteri) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameteri( params->texture, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureParameteriEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureParameteriEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameteriEXT( params->texture, params->target, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureParameteriv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum pname;
        PTR32 param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureParameteriv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameteriv( params->texture, params->pname, ULongToPtr(params->param) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureParameterivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureParameterivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureParameterivEXT( params->texture, params->target, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureRangeAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLsizei length;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureRangeAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureRangeAPPLE( params->target, params->length, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureRenderbufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLuint renderbuffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureRenderbufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureRenderbufferEXT( params->texture, params->target, params->renderbuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureStorage1D( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLsizei levels;
        GLenum internalformat;
        GLsizei width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureStorage1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage1D( params->texture, params->levels, params->internalformat, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureStorage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLsizei levels;
        GLenum internalformat;
        GLsizei width;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureStorage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage1DEXT( params->texture, params->target, params->levels, params->internalformat, params->width );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureStorage2D( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLsizei levels;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureStorage2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage2D( params->texture, params->levels, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureStorage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLsizei levels;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureStorage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage2DEXT( params->texture, params->target, params->levels, params->internalformat, params->width, params->height );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureStorage2DMultisample( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLsizei samples;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLboolean fixedsamplelocations;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureStorage2DMultisample) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage2DMultisample( params->texture, params->samples, params->internalformat, params->width, params->height, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureStorage2DMultisampleEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLsizei samples;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLboolean fixedsamplelocations;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureStorage2DMultisampleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage2DMultisampleEXT( params->texture, params->target, params->samples, params->internalformat, params->width, params->height, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureStorage3D( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLsizei levels;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureStorage3D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage3D( params->texture, params->levels, params->internalformat, params->width, params->height, params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureStorage3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLsizei levels;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureStorage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage3DEXT( params->texture, params->target, params->levels, params->internalformat, params->width, params->height, params->depth );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureStorage3DMultisample( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLsizei samples;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLboolean fixedsamplelocations;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureStorage3DMultisample) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage3DMultisample( params->texture, params->samples, params->internalformat, params->width, params->height, params->depth, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureStorage3DMultisampleEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLsizei samples;
        GLenum internalformat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLboolean fixedsamplelocations;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureStorage3DMultisampleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorage3DMultisampleEXT( params->texture, params->target, params->samples, params->internalformat, params->width, params->height, params->depth, params->fixedsamplelocations );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureStorageMem1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLsizei levels;
        GLenum internalFormat;
        GLsizei width;
        GLuint memory;
        GLuint64 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureStorageMem1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorageMem1DEXT( params->texture, params->levels, params->internalFormat, params->width, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureStorageMem2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLsizei levels;
        GLenum internalFormat;
        GLsizei width;
        GLsizei height;
        GLuint memory;
        GLuint64 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureStorageMem2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorageMem2DEXT( params->texture, params->levels, params->internalFormat, params->width, params->height, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureStorageMem2DMultisampleEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLsizei samples;
        GLenum internalFormat;
        GLsizei width;
        GLsizei height;
        GLboolean fixedSampleLocations;
        GLuint memory;
        GLuint64 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureStorageMem2DMultisampleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorageMem2DMultisampleEXT( params->texture, params->samples, params->internalFormat, params->width, params->height, params->fixedSampleLocations, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureStorageMem3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLsizei levels;
        GLenum internalFormat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLuint memory;
        GLuint64 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureStorageMem3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorageMem3DEXT( params->texture, params->levels, params->internalFormat, params->width, params->height, params->depth, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureStorageMem3DMultisampleEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLsizei samples;
        GLenum internalFormat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLboolean fixedSampleLocations;
        GLuint memory;
        GLuint64 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureStorageMem3DMultisampleEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorageMem3DMultisampleEXT( params->texture, params->samples, params->internalFormat, params->width, params->height, params->depth, params->fixedSampleLocations, params->memory, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureStorageSparseAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLenum internalFormat;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLsizei layers;
        GLbitfield flags;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureStorageSparseAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureStorageSparseAMD( params->texture, params->target, params->internalFormat, params->width, params->height, params->depth, params->layers, params->flags );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureSubImage1D( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLint xoffset;
        GLsizei width;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureSubImage1D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureSubImage1D( params->texture, params->level, params->xoffset, params->width, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureSubImage1DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLsizei width;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureSubImage1DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureSubImage1DEXT( params->texture, params->target, params->level, params->xoffset, params->width, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureSubImage2D( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureSubImage2D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureSubImage2D( params->texture, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureSubImage2DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLsizei width;
        GLsizei height;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureSubImage2DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureSubImage2DEXT( params->texture, params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureSubImage3D( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureSubImage3D) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureSubImage3D( params->texture, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureSubImage3DEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLint level;
        GLint xoffset;
        GLint yoffset;
        GLint zoffset;
        GLsizei width;
        GLsizei height;
        GLsizei depth;
        GLenum format;
        GLenum type;
        PTR32 pixels;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureSubImage3DEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureSubImage3DEXT( params->texture, params->target, params->level, params->xoffset, params->yoffset, params->zoffset, params->width, params->height, params->depth, params->format, params->type, ULongToPtr(params->pixels) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTextureView( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLenum target;
        GLuint origtexture;
        GLenum internalformat;
        GLuint minlevel;
        GLuint numlevels;
        GLuint minlayer;
        GLuint numlayers;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTextureView) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTextureView( params->texture, params->target, params->origtexture, params->internalformat, params->minlevel, params->numlevels, params->minlayer, params->numlayers );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTrackMatrixNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLuint address;
        GLenum matrix;
        GLenum transform;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTrackMatrixNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTrackMatrixNV( params->target, params->address, params->matrix, params->transform );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTransformFeedbackAttribsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei count;
        PTR32 attribs;
        GLenum bufferMode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTransformFeedbackAttribsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTransformFeedbackAttribsNV( params->count, ULongToPtr(params->attribs), params->bufferMode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTransformFeedbackBufferBase( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint xfb;
        GLuint index;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTransformFeedbackBufferBase) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTransformFeedbackBufferBase( params->xfb, params->index, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTransformFeedbackBufferRange( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint xfb;
        GLuint index;
        GLuint buffer;
        PTR32 offset;
        PTR32 size;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTransformFeedbackBufferRange) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTransformFeedbackBufferRange( params->xfb, params->index, params->buffer, (GLintptr)ULongToPtr(params->offset), (GLsizeiptr)ULongToPtr(params->size) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTransformFeedbackStreamAttribsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei count;
        PTR32 attribs;
        GLsizei nbuffers;
        PTR32 bufstreams;
        GLenum bufferMode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTransformFeedbackStreamAttribsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTransformFeedbackStreamAttribsNV( params->count, ULongToPtr(params->attribs), params->nbuffers, ULongToPtr(params->bufstreams), params->bufferMode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTransformFeedbackVaryings( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLsizei count;
        PTR32 varyings;
        GLenum bufferMode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const GLchar **varyings;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTransformFeedbackVaryings) return STATUS_NOT_IMPLEMENTED;
    varyings = copy_wow64_ptr32s( params->varyings, params->count );
    funcs->p_glTransformFeedbackVaryings( params->program, params->count, varyings, params->bufferMode );
    free( varyings );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTransformFeedbackVaryingsEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLsizei count;
        PTR32 varyings;
        GLenum bufferMode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const GLchar **varyings;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTransformFeedbackVaryingsEXT) return STATUS_NOT_IMPLEMENTED;
    varyings = copy_wow64_ptr32s( params->varyings, params->count );
    funcs->p_glTransformFeedbackVaryingsEXT( params->program, params->count, varyings, params->bufferMode );
    free( varyings );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTransformFeedbackVaryingsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLsizei count;
        PTR32 locations;
        GLenum bufferMode;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTransformFeedbackVaryingsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTransformFeedbackVaryingsNV( params->program, params->count, ULongToPtr(params->locations), params->bufferMode );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTransformPathNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint resultPath;
        GLuint srcPath;
        GLenum transformType;
        PTR32 transformValues;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTransformPathNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTransformPathNV( params->resultPath, params->srcPath, params->transformType, ULongToPtr(params->transformValues) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTranslatex( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed x;
        GLfixed y;
        GLfixed z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTranslatex) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTranslatex( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glTranslatexOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed x;
        GLfixed y;
        GLfixed z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glTranslatexOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glTranslatexOES( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1d( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLdouble x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1d( params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1dv( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1f( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLfloat v0;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1f( params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1fARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLfloat v0;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1fARB( params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1fv( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1fvARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLint v0;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1i( params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1i64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLint64 x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1i64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1i64ARB( params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1i64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLint64EXT x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1i64NV( params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1i64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1i64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1i64vARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1i64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1i64vNV( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1iARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLint v0;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1iARB( params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1iv( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1ivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1ivARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint v0;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1ui( params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1ui64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint64 x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1ui64ARB( params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1ui64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint64EXT x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1ui64NV( params->location, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1ui64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1ui64vARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1ui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1ui64vNV( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1uiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint v0;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1uiEXT( params->location, params->v0 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1uiv( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform1uivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform1uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform1uivEXT( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2d( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLdouble x;
        GLdouble y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2d( params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2dv( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2f( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLfloat v0;
        GLfloat v1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2f( params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2fARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLfloat v0;
        GLfloat v1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2fARB( params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2fv( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2fvARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLint v0;
        GLint v1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2i( params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2i64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLint64 x;
        GLint64 y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2i64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2i64ARB( params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2i64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLint64EXT x;
        GLint64EXT y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2i64NV( params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2i64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2i64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2i64vARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2i64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2i64vNV( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2iARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLint v0;
        GLint v1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2iARB( params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2iv( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2ivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2ivARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint v0;
        GLuint v1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2ui( params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2ui64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint64 x;
        GLuint64 y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2ui64ARB( params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2ui64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint64EXT x;
        GLuint64EXT y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2ui64NV( params->location, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2ui64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2ui64vARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2ui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2ui64vNV( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2uiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint v0;
        GLuint v1;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2uiEXT( params->location, params->v0, params->v1 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2uiv( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform2uivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform2uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform2uivEXT( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3d( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3d( params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3dv( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3f( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLfloat v0;
        GLfloat v1;
        GLfloat v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3f( params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3fARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLfloat v0;
        GLfloat v1;
        GLfloat v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3fARB( params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3fv( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3fvARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLint v0;
        GLint v1;
        GLint v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3i( params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3i64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLint64 x;
        GLint64 y;
        GLint64 z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3i64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3i64ARB( params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3i64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLint64EXT x;
        GLint64EXT y;
        GLint64EXT z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3i64NV( params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3i64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3i64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3i64vARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3i64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3i64vNV( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3iARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLint v0;
        GLint v1;
        GLint v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3iARB( params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3iv( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3ivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3ivARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint v0;
        GLuint v1;
        GLuint v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3ui( params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3ui64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint64 x;
        GLuint64 y;
        GLuint64 z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3ui64ARB( params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3ui64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint64EXT x;
        GLuint64EXT y;
        GLuint64EXT z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3ui64NV( params->location, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3ui64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3ui64vARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3ui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3ui64vNV( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3uiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint v0;
        GLuint v1;
        GLuint v2;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3uiEXT( params->location, params->v0, params->v1, params->v2 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3uiv( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform3uivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform3uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform3uivEXT( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4d( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLdouble x;
        GLdouble y;
        GLdouble z;
        GLdouble w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4d( params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4dv( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4f( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLfloat v0;
        GLfloat v1;
        GLfloat v2;
        GLfloat v3;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4f( params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4fARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLfloat v0;
        GLfloat v1;
        GLfloat v2;
        GLfloat v3;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4fARB( params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4fv( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4fvARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLint v0;
        GLint v1;
        GLint v2;
        GLint v3;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4i( params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4i64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLint64 x;
        GLint64 y;
        GLint64 z;
        GLint64 w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4i64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4i64ARB( params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4i64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLint64EXT x;
        GLint64EXT y;
        GLint64EXT z;
        GLint64EXT w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4i64NV( params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4i64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4i64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4i64vARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4i64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4i64vNV( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4iARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLint v0;
        GLint v1;
        GLint v2;
        GLint v3;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4iARB( params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4iv( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4ivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4ivARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint v0;
        GLuint v1;
        GLuint v2;
        GLuint v3;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4ui( params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4ui64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint64 x;
        GLuint64 y;
        GLuint64 z;
        GLuint64 w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4ui64ARB( params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4ui64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint64EXT x;
        GLuint64EXT y;
        GLuint64EXT z;
        GLuint64EXT w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4ui64NV( params->location, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4ui64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4ui64vARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4ui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4ui64vNV( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4uiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint v0;
        GLuint v1;
        GLuint v2;
        GLuint v3;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4uiEXT( params->location, params->v0, params->v1, params->v2, params->v3 );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4uiv( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniform4uivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniform4uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniform4uivEXT( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformBlockBinding( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLuint uniformBlockIndex;
        GLuint uniformBlockBinding;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformBlockBinding) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformBlockBinding( params->program, params->uniformBlockIndex, params->uniformBlockBinding );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformBufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
        GLint location;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformBufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformBufferEXT( params->program, params->location, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformHandleui64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint64 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformHandleui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformHandleui64ARB( params->location, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformHandleui64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint64 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformHandleui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformHandleui64NV( params->location, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformHandleui64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformHandleui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformHandleui64vARB( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformHandleui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformHandleui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformHandleui64vNV( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix2dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix2dv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix2fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix2fv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix2fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix2fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix2fvARB( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix2x3dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix2x3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix2x3dv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix2x3fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix2x3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix2x3fv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix2x4dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix2x4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix2x4dv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix2x4fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix2x4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix2x4fv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix3dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix3dv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix3fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix3fv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix3fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix3fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix3fvARB( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix3x2dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix3x2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix3x2dv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix3x2fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix3x2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix3x2fv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix3x4dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix3x4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix3x4dv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix3x4fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix3x4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix3x4fv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix4dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix4dv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix4fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix4fv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix4fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix4fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix4fvARB( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix4x2dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix4x2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix4x2dv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix4x2fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix4x2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix4x2fv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix4x3dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix4x3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix4x3dv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformMatrix4x3fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        GLboolean transpose;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformMatrix4x3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformMatrix4x3fv( params->location, params->count, params->transpose, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformSubroutinesuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum shadertype;
        GLsizei count;
        PTR32 indices;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformSubroutinesuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformSubroutinesuiv( params->shadertype, params->count, ULongToPtr(params->indices) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformui64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLuint64EXT value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformui64NV( params->location, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUniformui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint location;
        GLsizei count;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUniformui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUniformui64vNV( params->location, params->count, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUnlockArraysEXT( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUnlockArraysEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUnlockArraysEXT();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUnmapBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUnmapBuffer) return STATUS_NOT_IMPLEMENTED;
    params->ret = wow64_glUnmapBuffer( teb, params->target, funcs->p_glUnmapBuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUnmapBufferARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum target;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUnmapBufferARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = wow64_glUnmapBuffer( teb, params->target, funcs->p_glUnmapBufferARB );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUnmapNamedBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUnmapNamedBuffer) return STATUS_NOT_IMPLEMENTED;
    params->ret = wow64_glUnmapNamedBuffer( teb, params->buffer, funcs->p_glUnmapNamedBuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUnmapNamedBufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUnmapNamedBufferEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = wow64_glUnmapNamedBuffer( teb, params->buffer, funcs->p_glUnmapNamedBufferEXT );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUnmapObjectBufferATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUnmapObjectBufferATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUnmapObjectBufferATI( params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUnmapTexture2DINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint texture;
        GLint level;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUnmapTexture2DINTEL) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUnmapTexture2DINTEL( params->texture, params->level );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUpdateObjectBufferATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint buffer;
        GLuint offset;
        GLsizei size;
        PTR32 pointer;
        GLenum preserve;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUpdateObjectBufferATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUpdateObjectBufferATI( params->buffer, params->offset, params->size, ULongToPtr(params->pointer), params->preserve );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUploadGpuMaskNVX( void *args )
{
    struct
    {
        PTR32 teb;
        GLbitfield mask;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUploadGpuMaskNVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUploadGpuMaskNVX( params->mask );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUseProgram( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUseProgram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUseProgram( params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUseProgramObjectARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB programObj;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUseProgramObjectARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUseProgramObjectARB( params->programObj );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUseProgramStages( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint pipeline;
        GLbitfield stages;
        GLuint program;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUseProgramStages) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUseProgramStages( params->pipeline, params->stages, params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glUseShaderProgramEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLuint program;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glUseShaderProgramEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glUseShaderProgramEXT( params->type, params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVDPAUFiniNV( void *args )
{
    struct
    {
        PTR32 teb;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVDPAUFiniNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVDPAUFiniNV();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVDPAUGetSurfaceivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLvdpauSurfaceNV surface;
        GLenum pname;
        GLsizei count;
        PTR32 length;
        PTR32 values;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVDPAUGetSurfaceivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVDPAUGetSurfaceivNV( params->surface, params->pname, params->count, ULongToPtr(params->length), ULongToPtr(params->values) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVDPAUInitNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 vdpDevice;
        PTR32 getProcAddress;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVDPAUInitNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVDPAUInitNV( ULongToPtr(params->vdpDevice), ULongToPtr(params->getProcAddress) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVDPAUIsSurfaceNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLvdpauSurfaceNV surface;
        GLboolean ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVDPAUIsSurfaceNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glVDPAUIsSurfaceNV( params->surface );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVDPAUMapSurfacesNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei numSurfaces;
        PTR32 surfaces;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVDPAUMapSurfacesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVDPAUMapSurfacesNV( params->numSurfaces, ULongToPtr(params->surfaces) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVDPAURegisterOutputSurfaceNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 vdpSurface;
        GLenum target;
        GLsizei numTextureNames;
        PTR32 textureNames;
        GLvdpauSurfaceNV ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVDPAURegisterOutputSurfaceNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glVDPAURegisterOutputSurfaceNV( ULongToPtr(params->vdpSurface), params->target, params->numTextureNames, ULongToPtr(params->textureNames) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVDPAURegisterVideoSurfaceNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 vdpSurface;
        GLenum target;
        GLsizei numTextureNames;
        PTR32 textureNames;
        GLvdpauSurfaceNV ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVDPAURegisterVideoSurfaceNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glVDPAURegisterVideoSurfaceNV( ULongToPtr(params->vdpSurface), params->target, params->numTextureNames, ULongToPtr(params->textureNames) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVDPAURegisterVideoSurfaceWithPictureStructureNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 vdpSurface;
        GLenum target;
        GLsizei numTextureNames;
        PTR32 textureNames;
        GLboolean isFrameStructure;
        GLvdpauSurfaceNV ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVDPAURegisterVideoSurfaceWithPictureStructureNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glVDPAURegisterVideoSurfaceWithPictureStructureNV( ULongToPtr(params->vdpSurface), params->target, params->numTextureNames, ULongToPtr(params->textureNames), params->isFrameStructure );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVDPAUSurfaceAccessNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLvdpauSurfaceNV surface;
        GLenum access;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVDPAUSurfaceAccessNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVDPAUSurfaceAccessNV( params->surface, params->access );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVDPAUUnmapSurfacesNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei numSurface;
        PTR32 surfaces;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVDPAUUnmapSurfacesNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVDPAUUnmapSurfacesNV( params->numSurface, ULongToPtr(params->surfaces) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVDPAUUnregisterSurfaceNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLvdpauSurfaceNV surface;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVDPAUUnregisterSurfaceNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVDPAUUnregisterSurfaceNV( params->surface );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glValidateProgram( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint program;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glValidateProgram) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glValidateProgram( params->program );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glValidateProgramARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLhandleARB programObj;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glValidateProgramARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glValidateProgramARB( params->programObj );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glValidateProgramPipeline( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint pipeline;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glValidateProgramPipeline) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glValidateProgramPipeline( params->pipeline );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVariantArrayObjectATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum type;
        GLsizei stride;
        GLuint buffer;
        GLuint offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVariantArrayObjectATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantArrayObjectATI( params->id, params->type, params->stride, params->buffer, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVariantPointerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        GLenum type;
        GLuint stride;
        PTR32 addr;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVariantPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantPointerEXT( params->id, params->type, params->stride, ULongToPtr(params->addr) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVariantbvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        PTR32 addr;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVariantbvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantbvEXT( params->id, ULongToPtr(params->addr) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVariantdvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        PTR32 addr;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVariantdvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantdvEXT( params->id, ULongToPtr(params->addr) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVariantfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        PTR32 addr;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVariantfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantfvEXT( params->id, ULongToPtr(params->addr) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVariantivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        PTR32 addr;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVariantivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantivEXT( params->id, ULongToPtr(params->addr) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVariantsvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        PTR32 addr;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVariantsvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantsvEXT( params->id, ULongToPtr(params->addr) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVariantubvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        PTR32 addr;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVariantubvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantubvEXT( params->id, ULongToPtr(params->addr) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVariantuivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        PTR32 addr;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVariantuivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantuivEXT( params->id, ULongToPtr(params->addr) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVariantusvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint id;
        PTR32 addr;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVariantusvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVariantusvEXT( params->id, ULongToPtr(params->addr) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex2bOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLbyte x;
        GLbyte y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex2bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2bOES( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex2bvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex2bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2bvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex2hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLhalfNV x;
        GLhalfNV y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex2hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2hNV( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex2hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex2hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2hvNV( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex2xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex2xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2xOES( params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex2xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex2xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex2xvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex3bOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLbyte x;
        GLbyte y;
        GLbyte z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex3bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3bOES( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex3bvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex3bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3bvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex3hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLhalfNV x;
        GLhalfNV y;
        GLhalfNV z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex3hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3hNV( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex3hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex3hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3hvNV( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex3xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed x;
        GLfixed y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex3xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3xOES( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex3xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex3xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex3xvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex4bOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLbyte x;
        GLbyte y;
        GLbyte z;
        GLbyte w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex4bOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4bOES( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex4bvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex4bvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4bvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex4hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLhalfNV x;
        GLhalfNV y;
        GLhalfNV z;
        GLhalfNV w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex4hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4hNV( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex4hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex4hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4hvNV( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex4xOES( void *args )
{
    struct
    {
        PTR32 teb;
        GLfixed x;
        GLfixed y;
        GLfixed z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex4xOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4xOES( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertex4xvOES( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertex4xvOES) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertex4xvOES( ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayAttribBinding( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint attribindex;
        GLuint bindingindex;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayAttribBinding) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayAttribBinding( params->vaobj, params->attribindex, params->bindingindex );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayAttribFormat( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint attribindex;
        GLint size;
        GLenum type;
        GLboolean normalized;
        GLuint relativeoffset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayAttribFormat) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayAttribFormat( params->vaobj, params->attribindex, params->size, params->type, params->normalized, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayAttribIFormat( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint attribindex;
        GLint size;
        GLenum type;
        GLuint relativeoffset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayAttribIFormat) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayAttribIFormat( params->vaobj, params->attribindex, params->size, params->type, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayAttribLFormat( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint attribindex;
        GLint size;
        GLenum type;
        GLuint relativeoffset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayAttribLFormat) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayAttribLFormat( params->vaobj, params->attribindex, params->size, params->type, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayBindVertexBufferEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint bindingindex;
        GLuint buffer;
        PTR32 offset;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayBindVertexBufferEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayBindVertexBufferEXT( params->vaobj, params->bindingindex, params->buffer, (GLintptr)ULongToPtr(params->offset), params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayBindingDivisor( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint bindingindex;
        GLuint divisor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayBindingDivisor) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayBindingDivisor( params->vaobj, params->bindingindex, params->divisor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayColorOffsetEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint buffer;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayColorOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayColorOffsetEXT( params->vaobj, params->buffer, params->size, params->type, params->stride, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayEdgeFlagOffsetEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint buffer;
        GLsizei stride;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayEdgeFlagOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayEdgeFlagOffsetEXT( params->vaobj, params->buffer, params->stride, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayElementBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint buffer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayElementBuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayElementBuffer( params->vaobj, params->buffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayFogCoordOffsetEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint buffer;
        GLenum type;
        GLsizei stride;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayFogCoordOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayFogCoordOffsetEXT( params->vaobj, params->buffer, params->type, params->stride, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayIndexOffsetEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint buffer;
        GLenum type;
        GLsizei stride;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayIndexOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayIndexOffsetEXT( params->vaobj, params->buffer, params->type, params->stride, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayMultiTexCoordOffsetEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint buffer;
        GLenum texunit;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayMultiTexCoordOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayMultiTexCoordOffsetEXT( params->vaobj, params->buffer, params->texunit, params->size, params->type, params->stride, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayNormalOffsetEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint buffer;
        GLenum type;
        GLsizei stride;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayNormalOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayNormalOffsetEXT( params->vaobj, params->buffer, params->type, params->stride, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayParameteriAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayParameteriAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayParameteriAPPLE( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayRangeAPPLE( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei length;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayRangeAPPLE) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayRangeAPPLE( params->length, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayRangeNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei length;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayRangeNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayRangeNV( params->length, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArraySecondaryColorOffsetEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint buffer;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArraySecondaryColorOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArraySecondaryColorOffsetEXT( params->vaobj, params->buffer, params->size, params->type, params->stride, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayTexCoordOffsetEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint buffer;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayTexCoordOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayTexCoordOffsetEXT( params->vaobj, params->buffer, params->size, params->type, params->stride, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayVertexAttribBindingEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint attribindex;
        GLuint bindingindex;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayVertexAttribBindingEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexAttribBindingEXT( params->vaobj, params->attribindex, params->bindingindex );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayVertexAttribDivisorEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint index;
        GLuint divisor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayVertexAttribDivisorEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexAttribDivisorEXT( params->vaobj, params->index, params->divisor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayVertexAttribFormatEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint attribindex;
        GLint size;
        GLenum type;
        GLboolean normalized;
        GLuint relativeoffset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayVertexAttribFormatEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexAttribFormatEXT( params->vaobj, params->attribindex, params->size, params->type, params->normalized, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayVertexAttribIFormatEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint attribindex;
        GLint size;
        GLenum type;
        GLuint relativeoffset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayVertexAttribIFormatEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexAttribIFormatEXT( params->vaobj, params->attribindex, params->size, params->type, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayVertexAttribIOffsetEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint buffer;
        GLuint index;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayVertexAttribIOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexAttribIOffsetEXT( params->vaobj, params->buffer, params->index, params->size, params->type, params->stride, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayVertexAttribLFormatEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint attribindex;
        GLint size;
        GLenum type;
        GLuint relativeoffset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayVertexAttribLFormatEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexAttribLFormatEXT( params->vaobj, params->attribindex, params->size, params->type, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayVertexAttribLOffsetEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint buffer;
        GLuint index;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayVertexAttribLOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexAttribLOffsetEXT( params->vaobj, params->buffer, params->index, params->size, params->type, params->stride, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayVertexAttribOffsetEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint buffer;
        GLuint index;
        GLint size;
        GLenum type;
        GLboolean normalized;
        GLsizei stride;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayVertexAttribOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexAttribOffsetEXT( params->vaobj, params->buffer, params->index, params->size, params->type, params->normalized, params->stride, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayVertexBindingDivisorEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint bindingindex;
        GLuint divisor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayVertexBindingDivisorEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexBindingDivisorEXT( params->vaobj, params->bindingindex, params->divisor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayVertexBuffer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint bindingindex;
        GLuint buffer;
        PTR32 offset;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayVertexBuffer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexBuffer( params->vaobj, params->bindingindex, params->buffer, (GLintptr)ULongToPtr(params->offset), params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayVertexBuffers( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint first;
        GLsizei count;
        PTR32 buffers;
        PTR32 offsets;
        PTR32 strides;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    GLintptr *offsets;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayVertexBuffers) return STATUS_NOT_IMPLEMENTED;
    offsets = copy_wow64_ptr32s( params->offsets, params->count );
    funcs->p_glVertexArrayVertexBuffers( params->vaobj, params->first, params->count, ULongToPtr(params->buffers), offsets, ULongToPtr(params->strides) );
    free( offsets );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexArrayVertexOffsetEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint vaobj;
        GLuint buffer;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexArrayVertexOffsetEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexArrayVertexOffsetEXT( params->vaobj, params->buffer, params->size, params->type, params->stride, (GLintptr)ULongToPtr(params->offset) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1d( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1d( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1dARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1dARB( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1dNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1dNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1dNV( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1dv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1dvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1dvARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1dvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1dvNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1f( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLfloat x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1f( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1fARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLfloat x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1fARB( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1fNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLfloat x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1fNV( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1fv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1fvARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1fvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1fvNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLhalfNV x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1hNV( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1hvNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1s( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLshort x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1s( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1sARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLshort x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1sARB( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1sNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLshort x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1sNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1sNV( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1sv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1sv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1svARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1svARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib1svNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib1svNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib1svNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2d( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
        GLdouble y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2d( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2dARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
        GLdouble y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2dARB( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2dNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
        GLdouble y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2dNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2dNV( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2dv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2dvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2dvARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2dvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2dvNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2f( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLfloat x;
        GLfloat y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2f( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2fARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLfloat x;
        GLfloat y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2fARB( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2fNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLfloat x;
        GLfloat y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2fNV( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2fv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2fvARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2fvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2fvNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLhalfNV x;
        GLhalfNV y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2hNV( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2hvNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2s( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLshort x;
        GLshort y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2s( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2sARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLshort x;
        GLshort y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2sARB( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2sNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLshort x;
        GLshort y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2sNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2sNV( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2sv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2sv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2svARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2svARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib2svNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib2svNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib2svNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3d( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3d( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3dARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3dARB( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3dNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3dNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3dNV( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3dv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3dvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3dvARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3dvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3dvNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3f( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3f( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3fARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3fARB( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3fNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3fNV( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3fv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3fvARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3fvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3fvNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLhalfNV x;
        GLhalfNV y;
        GLhalfNV z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3hNV( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3hvNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3s( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLshort x;
        GLshort y;
        GLshort z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3s( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3sARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLshort x;
        GLshort y;
        GLshort z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3sARB( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3sNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLshort x;
        GLshort y;
        GLshort z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3sNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3sNV( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3sv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3sv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3svARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3svARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib3svNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib3svNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib3svNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4Nbv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4Nbv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4Nbv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4NbvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4NbvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4NbvARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4Niv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4Niv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4Niv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4NivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4NivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4NivARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4Nsv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4Nsv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4Nsv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4NsvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4NsvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4NsvARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4Nub( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLubyte x;
        GLubyte y;
        GLubyte z;
        GLubyte w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4Nub) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4Nub( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4NubARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLubyte x;
        GLubyte y;
        GLubyte z;
        GLubyte w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4NubARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4NubARB( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4Nubv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4Nubv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4Nubv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4NubvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4NubvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4NubvARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4Nuiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4Nuiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4Nuiv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4NuivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4NuivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4NuivARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4Nusv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4Nusv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4Nusv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4NusvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4NusvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4NusvARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4bv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4bv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4bv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4bvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4bvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4bvARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4d( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
        GLdouble y;
        GLdouble z;
        GLdouble w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4d( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4dARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
        GLdouble y;
        GLdouble z;
        GLdouble w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4dARB( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4dNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
        GLdouble y;
        GLdouble z;
        GLdouble w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4dNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4dNV( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4dv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4dvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4dvARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4dvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4dvNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4f( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLfloat x;
        GLfloat y;
        GLfloat z;
        GLfloat w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4f( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4fARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLfloat x;
        GLfloat y;
        GLfloat z;
        GLfloat w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4fARB( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4fNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLfloat x;
        GLfloat y;
        GLfloat z;
        GLfloat w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4fNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4fNV( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4fv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4fv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4fvARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4fvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4fvNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4hNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLhalfNV x;
        GLhalfNV y;
        GLhalfNV z;
        GLhalfNV w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4hNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4hNV( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4hvNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4iv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4ivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4ivARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4s( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLshort x;
        GLshort y;
        GLshort z;
        GLshort w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4s( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4sARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLshort x;
        GLshort y;
        GLshort z;
        GLshort w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4sARB( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4sNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLshort x;
        GLshort y;
        GLshort z;
        GLshort w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4sNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4sNV( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4sv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4sv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4svARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4svARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4svNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4svNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4svNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4ubNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLubyte x;
        GLubyte y;
        GLubyte z;
        GLubyte w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4ubNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4ubNV( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4ubv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4ubv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4ubv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4ubvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4ubvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4ubvARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4ubvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4ubvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4ubvNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4uiv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4uivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4uivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4uivARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4usv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4usv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4usv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttrib4usvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttrib4usvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttrib4usvARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribArrayObjectATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint size;
        GLenum type;
        GLboolean normalized;
        GLsizei stride;
        GLuint buffer;
        GLuint offset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribArrayObjectATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribArrayObjectATI( params->index, params->size, params->type, params->normalized, params->stride, params->buffer, params->offset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribBinding( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint attribindex;
        GLuint bindingindex;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribBinding) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribBinding( params->attribindex, params->bindingindex );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribDivisor( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint divisor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribDivisor) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribDivisor( params->index, params->divisor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribDivisorARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint divisor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribDivisorARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribDivisorARB( params->index, params->divisor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribFormat( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint attribindex;
        GLint size;
        GLenum type;
        GLboolean normalized;
        GLuint relativeoffset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribFormat) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribFormat( params->attribindex, params->size, params->type, params->normalized, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribFormatNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint size;
        GLenum type;
        GLboolean normalized;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribFormatNV( params->index, params->size, params->type, params->normalized, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI1i( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI1i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI1i( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI1iEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI1iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI1iEXT( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI1iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI1iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI1iv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI1ivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI1ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI1ivEXT( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI1ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI1ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI1ui( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI1uiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI1uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI1uiEXT( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI1uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI1uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI1uiv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI1uivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI1uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI1uivEXT( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI2i( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint x;
        GLint y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI2i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI2i( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI2iEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint x;
        GLint y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI2iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI2iEXT( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI2iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI2iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI2iv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI2ivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI2ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI2ivEXT( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI2ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint x;
        GLuint y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI2ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI2ui( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI2uiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint x;
        GLuint y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI2uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI2uiEXT( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI2uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI2uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI2uiv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI2uivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI2uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI2uivEXT( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI3i( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint x;
        GLint y;
        GLint z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI3i( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI3iEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint x;
        GLint y;
        GLint z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI3iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI3iEXT( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI3iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI3iv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI3ivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI3ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI3ivEXT( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI3ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint x;
        GLuint y;
        GLuint z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI3ui( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI3uiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint x;
        GLuint y;
        GLuint z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI3uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI3uiEXT( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI3uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI3uiv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI3uivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI3uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI3uivEXT( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI4bv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI4bv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4bv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI4bvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI4bvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4bvEXT( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI4i( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint x;
        GLint y;
        GLint z;
        GLint w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI4i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4i( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI4iEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint x;
        GLint y;
        GLint z;
        GLint w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI4iEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4iEXT( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI4iv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI4iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4iv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI4ivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI4ivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4ivEXT( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI4sv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI4sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4sv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI4svEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI4svEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4svEXT( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI4ubv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI4ubv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4ubv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI4ubvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI4ubvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4ubvEXT( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI4ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint x;
        GLuint y;
        GLuint z;
        GLuint w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4ui( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI4uiEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint x;
        GLuint y;
        GLuint z;
        GLuint w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI4uiEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4uiEXT( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI4uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4uiv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI4uivEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI4uivEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4uivEXT( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI4usv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI4usv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4usv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribI4usvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribI4usvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribI4usvEXT( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribIFormat( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint attribindex;
        GLint size;
        GLenum type;
        GLuint relativeoffset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribIFormat) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribIFormat( params->attribindex, params->size, params->type, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribIFormatNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint size;
        GLenum type;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribIFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribIFormatNV( params->index, params->size, params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribIPointer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribIPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribIPointer( params->index, params->size, params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribIPointerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribIPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribIPointerEXT( params->index, params->size, params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL1d( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL1d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1d( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL1dEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL1dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1dEXT( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL1dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL1dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1dv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL1dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL1dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1dvEXT( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL1i64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint64EXT x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL1i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1i64NV( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL1i64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL1i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1i64vNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL1ui64ARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint64EXT x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL1ui64ARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1ui64ARB( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL1ui64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint64EXT x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL1ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1ui64NV( params->index, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL1ui64vARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL1ui64vARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1ui64vARB( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL1ui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL1ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL1ui64vNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL2d( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
        GLdouble y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL2d( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL2dEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
        GLdouble y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL2dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL2dEXT( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL2dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL2dv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL2dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL2dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL2dvEXT( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL2i64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint64EXT x;
        GLint64EXT y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL2i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL2i64NV( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL2i64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL2i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL2i64vNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL2ui64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint64EXT x;
        GLuint64EXT y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL2ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL2ui64NV( params->index, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL2ui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL2ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL2ui64vNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL3d( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL3d( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL3dEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL3dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL3dEXT( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL3dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL3dv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL3dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL3dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL3dvEXT( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL3i64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint64EXT x;
        GLint64EXT y;
        GLint64EXT z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL3i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL3i64NV( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL3i64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL3i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL3i64vNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL3ui64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint64EXT x;
        GLuint64EXT y;
        GLuint64EXT z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL3ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL3ui64NV( params->index, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL3ui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL3ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL3ui64vNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL4d( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
        GLdouble y;
        GLdouble z;
        GLdouble w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL4d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL4d( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL4dEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLdouble x;
        GLdouble y;
        GLdouble z;
        GLdouble w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL4dEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL4dEXT( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL4dv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL4dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL4dv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL4dvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL4dvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL4dvEXT( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL4i64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint64EXT x;
        GLint64EXT y;
        GLint64EXT z;
        GLint64EXT w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL4i64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL4i64NV( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL4i64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL4i64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL4i64vNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL4ui64NV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLuint64EXT x;
        GLuint64EXT y;
        GLuint64EXT z;
        GLuint64EXT w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL4ui64NV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL4ui64NV( params->index, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribL4ui64vNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribL4ui64vNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribL4ui64vNV( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribLFormat( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint attribindex;
        GLint size;
        GLenum type;
        GLuint relativeoffset;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribLFormat) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribLFormat( params->attribindex, params->size, params->type, params->relativeoffset );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribLFormatNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint size;
        GLenum type;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribLFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribLFormatNV( params->index, params->size, params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribLPointer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribLPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribLPointer( params->index, params->size, params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribLPointerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribLPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribLPointerEXT( params->index, params->size, params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribP1ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum type;
        GLboolean normalized;
        GLuint value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribP1ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribP1ui( params->index, params->type, params->normalized, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribP1uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum type;
        GLboolean normalized;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribP1uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribP1uiv( params->index, params->type, params->normalized, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribP2ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum type;
        GLboolean normalized;
        GLuint value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribP2ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribP2ui( params->index, params->type, params->normalized, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribP2uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum type;
        GLboolean normalized;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribP2uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribP2uiv( params->index, params->type, params->normalized, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribP3ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum type;
        GLboolean normalized;
        GLuint value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribP3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribP3ui( params->index, params->type, params->normalized, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribP3uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum type;
        GLboolean normalized;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribP3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribP3uiv( params->index, params->type, params->normalized, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribP4ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum type;
        GLboolean normalized;
        GLuint value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribP4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribP4ui( params->index, params->type, params->normalized, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribP4uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum type;
        GLboolean normalized;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribP4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribP4uiv( params->index, params->type, params->normalized, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribParameteriAMD( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribParameteriAMD) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribParameteriAMD( params->index, params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribPointer( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint size;
        GLenum type;
        GLboolean normalized;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribPointer) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribPointer( params->index, params->size, params->type, params->normalized, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribPointerARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint size;
        GLenum type;
        GLboolean normalized;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribPointerARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribPointerARB( params->index, params->size, params->type, params->normalized, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribPointerNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLint fsize;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribPointerNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribPointerNV( params->index, params->fsize, params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs1dvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs1dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs1dvNV( params->index, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs1fvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs1fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs1fvNV( params->index, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs1hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei n;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs1hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs1hvNV( params->index, params->n, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs1svNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs1svNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs1svNV( params->index, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs2dvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs2dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs2dvNV( params->index, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs2fvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs2fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs2fvNV( params->index, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs2hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei n;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs2hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs2hvNV( params->index, params->n, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs2svNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs2svNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs2svNV( params->index, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs3dvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs3dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs3dvNV( params->index, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs3fvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs3fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs3fvNV( params->index, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs3hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei n;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs3hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs3hvNV( params->index, params->n, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs3svNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs3svNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs3svNV( params->index, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs4dvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs4dvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs4dvNV( params->index, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs4fvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs4fvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs4fvNV( params->index, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs4hvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei n;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs4hvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs4hvNV( params->index, params->n, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs4svNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs4svNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs4svNV( params->index, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexAttribs4ubvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexAttribs4ubvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexAttribs4ubvNV( params->index, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexBindingDivisor( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint bindingindex;
        GLuint divisor;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexBindingDivisor) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexBindingDivisor( params->bindingindex, params->divisor );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexBlendARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint count;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexBlendARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexBlendARB( params->count );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexBlendEnvfATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLfloat param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexBlendEnvfATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexBlendEnvfATI( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexBlendEnviATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum pname;
        GLint param;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexBlendEnviATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexBlendEnviATI( params->pname, params->param );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexFormatNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLsizei stride;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexFormatNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexFormatNV( params->size, params->type, params->stride );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexP2ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLuint value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexP2ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexP2ui( params->type, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexP2uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexP2uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexP2uiv( params->type, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexP3ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLuint value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexP3ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexP3ui( params->type, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexP3uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexP3uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexP3uiv( params->type, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexP4ui( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        GLuint value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexP4ui) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexP4ui( params->type, params->value );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexP4uiv( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum type;
        PTR32 value;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexP4uiv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexP4uiv( params->type, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexPointerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLsizei stride;
        GLsizei count;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexPointerEXT( params->size, params->type, params->stride, params->count, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexPointerListIBM( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLint stride;
        PTR32 pointer;
        GLint ptrstride;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glVertexPointervINTEL( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        PTR32 pointer;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_glVertexStream1dATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLdouble x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream1dATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream1dATI( params->stream, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream1dvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream1dvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream1dvATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream1fATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLfloat x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream1fATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream1fATI( params->stream, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream1fvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream1fvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream1fvATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream1iATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLint x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream1iATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream1iATI( params->stream, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream1ivATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream1ivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream1ivATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream1sATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLshort x;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream1sATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream1sATI( params->stream, params->x );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream1svATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream1svATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream1svATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream2dATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLdouble x;
        GLdouble y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream2dATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream2dATI( params->stream, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream2dvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream2dvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream2dvATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream2fATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLfloat x;
        GLfloat y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream2fATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream2fATI( params->stream, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream2fvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream2fvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream2fvATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream2iATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLint x;
        GLint y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream2iATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream2iATI( params->stream, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream2ivATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream2ivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream2ivATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream2sATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLshort x;
        GLshort y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream2sATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream2sATI( params->stream, params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream2svATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream2svATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream2svATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream3dATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream3dATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream3dATI( params->stream, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream3dvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream3dvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream3dvATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream3fATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream3fATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream3fATI( params->stream, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream3fvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream3fvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream3fvATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream3iATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLint x;
        GLint y;
        GLint z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream3iATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream3iATI( params->stream, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream3ivATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream3ivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream3ivATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream3sATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLshort x;
        GLshort y;
        GLshort z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream3sATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream3sATI( params->stream, params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream3svATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream3svATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream3svATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream4dATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLdouble x;
        GLdouble y;
        GLdouble z;
        GLdouble w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream4dATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream4dATI( params->stream, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream4dvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream4dvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream4dvATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream4fATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLfloat x;
        GLfloat y;
        GLfloat z;
        GLfloat w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream4fATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream4fATI( params->stream, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream4fvATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream4fvATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream4fvATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream4iATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLint x;
        GLint y;
        GLint z;
        GLint w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream4iATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream4iATI( params->stream, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream4ivATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream4ivATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream4ivATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream4sATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        GLshort x;
        GLshort y;
        GLshort z;
        GLshort w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream4sATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream4sATI( params->stream, params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexStream4svATI( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum stream;
        PTR32 coords;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexStream4svATI) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexStream4svATI( params->stream, ULongToPtr(params->coords) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexWeightPointerEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexWeightPointerEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexWeightPointerEXT( params->size, params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexWeightfEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat weight;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexWeightfEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexWeightfEXT( params->weight );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexWeightfvEXT( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 weight;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexWeightfvEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexWeightfvEXT( ULongToPtr(params->weight) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexWeighthNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLhalfNV weight;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexWeighthNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexWeighthNV( params->weight );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVertexWeighthvNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 weight;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVertexWeighthvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVertexWeighthvNV( ULongToPtr(params->weight) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVideoCaptureNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_capture_slot;
        PTR32 sequence_num;
        PTR32 capture_time;
        GLenum ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVideoCaptureNV) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_glVideoCaptureNV( params->video_capture_slot, ULongToPtr(params->sequence_num), ULongToPtr(params->capture_time) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVideoCaptureStreamParameterdvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_capture_slot;
        GLuint stream;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVideoCaptureStreamParameterdvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVideoCaptureStreamParameterdvNV( params->video_capture_slot, params->stream, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVideoCaptureStreamParameterfvNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_capture_slot;
        GLuint stream;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVideoCaptureStreamParameterfvNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVideoCaptureStreamParameterfvNV( params->video_capture_slot, params->stream, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glVideoCaptureStreamParameterivNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint video_capture_slot;
        GLuint stream;
        GLenum pname;
        PTR32 params;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glVideoCaptureStreamParameterivNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glVideoCaptureStreamParameterivNV( params->video_capture_slot, params->stream, params->pname, ULongToPtr(params->params) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glViewportArrayv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint first;
        GLsizei count;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glViewportArrayv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glViewportArrayv( params->first, params->count, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glViewportIndexedf( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLfloat x;
        GLfloat y;
        GLfloat w;
        GLfloat h;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glViewportIndexedf) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glViewportIndexedf( params->index, params->x, params->y, params->w, params->h );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glViewportIndexedfv( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glViewportIndexedfv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glViewportIndexedfv( params->index, ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glViewportPositionWScaleNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLfloat xcoeff;
        GLfloat ycoeff;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glViewportPositionWScaleNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glViewportPositionWScaleNV( params->index, params->xcoeff, params->ycoeff );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glViewportSwizzleNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint index;
        GLenum swizzlex;
        GLenum swizzley;
        GLenum swizzlez;
        GLenum swizzlew;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glViewportSwizzleNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glViewportSwizzleNV( params->index, params->swizzlex, params->swizzley, params->swizzlez, params->swizzlew );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWaitSemaphoreEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint semaphore;
        GLuint numBufferBarriers;
        PTR32 buffers;
        GLuint numTextureBarriers;
        PTR32 textures;
        PTR32 srcLayouts;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWaitSemaphoreEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWaitSemaphoreEXT( params->semaphore, params->numBufferBarriers, ULongToPtr(params->buffers), params->numTextureBarriers, ULongToPtr(params->textures), ULongToPtr(params->srcLayouts) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWaitSemaphoreui64NVX( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint waitGpu;
        GLsizei fenceObjectCount;
        PTR32 semaphoreArray;
        PTR32 fenceValueArray;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWaitSemaphoreui64NVX) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWaitSemaphoreui64NVX( params->waitGpu, params->fenceObjectCount, ULongToPtr(params->semaphoreArray), ULongToPtr(params->fenceValueArray) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWaitSync( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 sync;
        GLbitfield flags;
        GLuint64 timeout;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWaitSync) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWaitSync( get_unix_sync( ULongToPtr(params->sync) ), params->flags, params->timeout );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWaitVkSemaphoreNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint64 vkSemaphore;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWaitVkSemaphoreNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWaitVkSemaphoreNV( params->vkSemaphore );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWeightPathsNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint resultPath;
        GLsizei numPaths;
        PTR32 paths;
        PTR32 weights;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWeightPathsNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightPathsNV( params->resultPath, params->numPaths, ULongToPtr(params->paths), ULongToPtr(params->weights) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWeightPointerARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        GLenum type;
        GLsizei stride;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWeightPointerARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightPointerARB( params->size, params->type, params->stride, ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWeightbvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        PTR32 weights;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWeightbvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightbvARB( params->size, ULongToPtr(params->weights) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWeightdvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        PTR32 weights;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWeightdvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightdvARB( params->size, ULongToPtr(params->weights) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWeightfvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        PTR32 weights;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWeightfvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightfvARB( params->size, ULongToPtr(params->weights) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWeightivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        PTR32 weights;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWeightivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightivARB( params->size, ULongToPtr(params->weights) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWeightsvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        PTR32 weights;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWeightsvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightsvARB( params->size, ULongToPtr(params->weights) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWeightubvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        PTR32 weights;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWeightubvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightubvARB( params->size, ULongToPtr(params->weights) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWeightuivARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        PTR32 weights;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWeightuivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightuivARB( params->size, ULongToPtr(params->weights) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWeightusvARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint size;
        PTR32 weights;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWeightusvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWeightusvARB( params->size, ULongToPtr(params->weights) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble x;
        GLdouble y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2d( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2dARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble x;
        GLdouble y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2dARB( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2dMESA( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble x;
        GLdouble y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2dMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2dMESA( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2dv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2dvARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2dvARB( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2dvMESA( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2dvMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2dvMESA( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat x;
        GLfloat y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2f( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2fARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat x;
        GLfloat y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2fARB( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2fMESA( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat x;
        GLfloat y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2fMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2fMESA( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2fv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2fvARB( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2fvMESA( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2fvMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2fvMESA( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2i( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2iARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2iARB( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2iMESA( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2iMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2iMESA( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2iv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2iv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2ivARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2ivARB( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2ivMESA( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2ivMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2ivMESA( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2s( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort x;
        GLshort y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2s( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2sARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort x;
        GLshort y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2sARB( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2sMESA( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort x;
        GLshort y;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2sMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2sMESA( params->x, params->y );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2sv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2sv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2svARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2svARB( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos2svMESA( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos2svMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos2svMESA( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3d( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3d) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3d( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3dARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3dARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3dARB( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3dMESA( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble x;
        GLdouble y;
        GLdouble z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3dMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3dMESA( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3dv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3dv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3dv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3dvARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3dvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3dvARB( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3dvMESA( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3dvMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3dvMESA( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3f( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3f) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3f( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3fARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3fARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3fARB( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3fMESA( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat x;
        GLfloat y;
        GLfloat z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3fMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3fMESA( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3fv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3fv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3fv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3fvARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3fvARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3fvARB( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3fvMESA( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3fvMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3fvMESA( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3i( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
        GLint z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3i) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3i( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3iARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
        GLint z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3iARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3iARB( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3iMESA( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
        GLint z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3iMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3iMESA( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3iv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3iv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3iv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3ivARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3ivARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3ivARB( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3ivMESA( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3ivMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3ivMESA( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3s( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort x;
        GLshort y;
        GLshort z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3s) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3s( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3sARB( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort x;
        GLshort y;
        GLshort z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3sARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3sARB( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3sMESA( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort x;
        GLshort y;
        GLshort z;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3sMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3sMESA( params->x, params->y, params->z );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3sv( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3sv) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3sv( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3svARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3svARB) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3svARB( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos3svMESA( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos3svMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos3svMESA( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos4dMESA( void *args )
{
    struct
    {
        PTR32 teb;
        GLdouble x;
        GLdouble y;
        GLdouble z;
        GLdouble w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos4dMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos4dMESA( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos4dvMESA( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos4dvMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos4dvMESA( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos4fMESA( void *args )
{
    struct
    {
        PTR32 teb;
        GLfloat x;
        GLfloat y;
        GLfloat z;
        GLfloat w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos4fMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos4fMESA( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos4fvMESA( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos4fvMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos4fvMESA( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos4iMESA( void *args )
{
    struct
    {
        PTR32 teb;
        GLint x;
        GLint y;
        GLint z;
        GLint w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos4iMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos4iMESA( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos4ivMESA( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos4ivMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos4ivMESA( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos4sMESA( void *args )
{
    struct
    {
        PTR32 teb;
        GLshort x;
        GLshort y;
        GLshort z;
        GLshort w;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos4sMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos4sMESA( params->x, params->y, params->z, params->w );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowPos4svMESA( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 v;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowPos4svMESA) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowPos4svMESA( ULongToPtr(params->v) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWindowRectanglesEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum mode;
        GLsizei count;
        PTR32 box;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWindowRectanglesEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWindowRectanglesEXT( params->mode, params->count, ULongToPtr(params->box) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_glWriteMaskEXT( void *args )
{
    struct
    {
        PTR32 teb;
        GLuint res;
        GLuint in;
        GLenum outX;
        GLenum outY;
        GLenum outZ;
        GLenum outW;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_glWriteMaskEXT) return STATUS_NOT_IMPLEMENTED;
    funcs->p_glWriteMaskEXT( params->res, params->in, params->outX, params->outY, params->outZ, params->outW );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_wglAllocateMemoryNV( void *args )
{
    struct
    {
        PTR32 teb;
        GLsizei size;
        GLfloat readfreq;
        GLfloat writefreq;
        GLfloat priority;
        PTR32 ret;
    } *params = args;
    FIXME( "params %p stub!\n", params );
    return STATUS_NOT_IMPLEMENTED;
}

static NTSTATUS wow64_ext_wglBindTexImageARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 hPbuffer;
        int iBuffer;
        BOOL ret;
    } *params = args;
    const struct opengl_funcs *funcs = get_pbuffer_funcs( ULongToPtr(params->hPbuffer) );
    if (!funcs || !funcs->p_wglBindTexImageARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglBindTexImageARB( ULongToPtr(params->hPbuffer), params->iBuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_wglCreateContextAttribsARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 hDC;
        PTR32 hShareContext;
        PTR32 attribList;
        PTR32 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    params->ret = (UINT_PTR)wrap_wglCreateContextAttribsARB( teb, ULongToPtr(params->hDC), ULongToPtr(params->hShareContext), ULongToPtr(params->attribList), UlongToHandle( params->ret ) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_wglCreatePbufferARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 hDC;
        int iPixelFormat;
        int iWidth;
        int iHeight;
        PTR32 piAttribList;
        PTR32 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    params->ret = (UINT_PTR)wrap_wglCreatePbufferARB( teb, ULongToPtr(params->hDC), params->iPixelFormat, params->iWidth, params->iHeight, ULongToPtr(params->piAttribList), UlongToHandle( params->ret ) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_wglDestroyPbufferARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 hPbuffer;
        BOOL ret;
    } *params = args;
    const struct opengl_funcs *funcs = get_pbuffer_funcs( ULongToPtr(params->hPbuffer) );
    if (!funcs || !funcs->p_wglDestroyPbufferARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglDestroyPbufferARB( ULongToPtr(params->hPbuffer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_wglFreeMemoryNV( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 pointer;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_wglFreeMemoryNV) return STATUS_NOT_IMPLEMENTED;
    funcs->p_wglFreeMemoryNV( ULongToPtr(params->pointer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_wglGetPbufferDCARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 hPbuffer;
        PTR32 ret;
    } *params = args;
    const struct opengl_funcs *funcs = get_pbuffer_funcs( ULongToPtr(params->hPbuffer) );
    if (!funcs || !funcs->p_wglGetPbufferDCARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = (UINT_PTR)funcs->p_wglGetPbufferDCARB( ULongToPtr(params->hPbuffer) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_wglGetSwapIntervalEXT( void *args )
{
    struct
    {
        PTR32 teb;
        int ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_wglGetSwapIntervalEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglGetSwapIntervalEXT();
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_wglMakeContextCurrentARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 hDrawDC;
        PTR32 hReadDC;
        PTR32 hglrc;
        BOOL ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    params->ret = wrap_wglMakeContextCurrentARB( teb, ULongToPtr(params->hDrawDC), ULongToPtr(params->hReadDC), ULongToPtr(params->hglrc) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_wglQueryCurrentRendererIntegerWINE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum attribute;
        PTR32 value;
        BOOL ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_wglQueryCurrentRendererIntegerWINE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglQueryCurrentRendererIntegerWINE( params->attribute, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_wglQueryCurrentRendererStringWINE( void *args )
{
    struct
    {
        PTR32 teb;
        GLenum attribute;
        PTR32 ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const GLchar *ret;
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_wglQueryCurrentRendererStringWINE) return STATUS_NOT_IMPLEMENTED;
    ret = funcs->p_wglQueryCurrentRendererStringWINE( params->attribute );
    return return_wow64_string( ret, &params->ret );
}

static NTSTATUS wow64_ext_wglQueryPbufferARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 hPbuffer;
        int iAttribute;
        PTR32 piValue;
        BOOL ret;
    } *params = args;
    const struct opengl_funcs *funcs = get_pbuffer_funcs( ULongToPtr(params->hPbuffer) );
    if (!funcs || !funcs->p_wglQueryPbufferARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglQueryPbufferARB( ULongToPtr(params->hPbuffer), params->iAttribute, ULongToPtr(params->piValue) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_wglQueryRendererIntegerWINE( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 dc;
        GLint renderer;
        GLenum attribute;
        PTR32 value;
        BOOL ret;
    } *params = args;
    const struct opengl_funcs *funcs = get_dc_funcs( ULongToPtr(params->dc) );
    if (!funcs || !funcs->p_wglQueryRendererIntegerWINE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglQueryRendererIntegerWINE( ULongToPtr(params->dc), params->renderer, params->attribute, ULongToPtr(params->value) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_wglQueryRendererStringWINE( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 dc;
        GLint renderer;
        GLenum attribute;
        PTR32 ret;
    } *params = args;
    const GLchar *ret;
    const struct opengl_funcs *funcs = get_dc_funcs( ULongToPtr(params->dc) );
    if (!funcs || !funcs->p_wglQueryRendererStringWINE) return STATUS_NOT_IMPLEMENTED;
    ret = funcs->p_wglQueryRendererStringWINE( ULongToPtr(params->dc), params->renderer, params->attribute );
    return return_wow64_string( ret, &params->ret );
}

static NTSTATUS wow64_ext_wglReleasePbufferDCARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 hPbuffer;
        PTR32 hDC;
        int ret;
    } *params = args;
    const struct opengl_funcs *funcs = get_pbuffer_funcs( ULongToPtr(params->hPbuffer) );
    if (!funcs || !funcs->p_wglReleasePbufferDCARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglReleasePbufferDCARB( ULongToPtr(params->hPbuffer), ULongToPtr(params->hDC) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_wglReleaseTexImageARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 hPbuffer;
        int iBuffer;
        BOOL ret;
    } *params = args;
    const struct opengl_funcs *funcs = get_pbuffer_funcs( ULongToPtr(params->hPbuffer) );
    if (!funcs || !funcs->p_wglReleaseTexImageARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglReleaseTexImageARB( ULongToPtr(params->hPbuffer), params->iBuffer );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_wglSetPbufferAttribARB( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 hPbuffer;
        PTR32 piAttribList;
        BOOL ret;
    } *params = args;
    const struct opengl_funcs *funcs = get_pbuffer_funcs( ULongToPtr(params->hPbuffer) );
    if (!funcs || !funcs->p_wglSetPbufferAttribARB) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglSetPbufferAttribARB( ULongToPtr(params->hPbuffer), ULongToPtr(params->piAttribList) );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_wglSetPixelFormatWINE( void *args )
{
    struct
    {
        PTR32 teb;
        PTR32 hdc;
        int format;
        BOOL ret;
    } *params = args;
    const struct opengl_funcs *funcs = get_dc_funcs( ULongToPtr(params->hdc) );
    if (!funcs || !funcs->p_wglSetPixelFormatWINE) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglSetPixelFormatWINE( ULongToPtr(params->hdc), params->format );
    return STATUS_SUCCESS;
}

static NTSTATUS wow64_ext_wglSwapIntervalEXT( void *args )
{
    struct
    {
        PTR32 teb;
        int interval;
        BOOL ret;
    } *params = args;
    TEB *teb = get_teb64( params->teb );
    const struct opengl_funcs *funcs = teb->glTable;
    if (!funcs->p_wglSwapIntervalEXT) return STATUS_NOT_IMPLEMENTED;
    params->ret = funcs->p_wglSwapIntervalEXT( params->interval );
    return STATUS_SUCCESS;
}


const unixlib_entry_t __wine_unix_call_wow64_funcs[] =
{
    process_attach,
    wow64_thread_attach,
    wow64_process_detach,
    wow64_get_pixel_formats,
    wow64_wgl_wglDeleteContext,
    wow64_wgl_wglGetPixelFormat,
    wow64_wgl_wglSetPixelFormat,
    wow64_wgl_wglSwapBuffers,
    wow64_gl_glAccum,
    wow64_gl_glAlphaFunc,
    wow64_gl_glAreTexturesResident,
    wow64_gl_glArrayElement,
    wow64_gl_glBegin,
    wow64_gl_glBindTexture,
    wow64_gl_glBitmap,
    wow64_gl_glBlendFunc,
    wow64_gl_glCallList,
    wow64_gl_glCallLists,
    wow64_gl_glClear,
    wow64_gl_glClearAccum,
    wow64_gl_glClearColor,
    wow64_gl_glClearDepth,
    wow64_gl_glClearIndex,
    wow64_gl_glClearStencil,
    wow64_gl_glClipPlane,
    wow64_gl_glColor3b,
    wow64_gl_glColor3bv,
    wow64_gl_glColor3d,
    wow64_gl_glColor3dv,
    wow64_gl_glColor3f,
    wow64_gl_glColor3fv,
    wow64_gl_glColor3i,
    wow64_gl_glColor3iv,
    wow64_gl_glColor3s,
    wow64_gl_glColor3sv,
    wow64_gl_glColor3ub,
    wow64_gl_glColor3ubv,
    wow64_gl_glColor3ui,
    wow64_gl_glColor3uiv,
    wow64_gl_glColor3us,
    wow64_gl_glColor3usv,
    wow64_gl_glColor4b,
    wow64_gl_glColor4bv,
    wow64_gl_glColor4d,
    wow64_gl_glColor4dv,
    wow64_gl_glColor4f,
    wow64_gl_glColor4fv,
    wow64_gl_glColor4i,
    wow64_gl_glColor4iv,
    wow64_gl_glColor4s,
    wow64_gl_glColor4sv,
    wow64_gl_glColor4ub,
    wow64_gl_glColor4ubv,
    wow64_gl_glColor4ui,
    wow64_gl_glColor4uiv,
    wow64_gl_glColor4us,
    wow64_gl_glColor4usv,
    wow64_gl_glColorMask,
    wow64_gl_glColorMaterial,
    wow64_gl_glColorPointer,
    wow64_gl_glCopyPixels,
    wow64_gl_glCopyTexImage1D,
    wow64_gl_glCopyTexImage2D,
    wow64_gl_glCopyTexSubImage1D,
    wow64_gl_glCopyTexSubImage2D,
    wow64_gl_glCullFace,
    wow64_gl_glDeleteLists,
    wow64_gl_glDeleteTextures,
    wow64_gl_glDepthFunc,
    wow64_gl_glDepthMask,
    wow64_gl_glDepthRange,
    wow64_gl_glDisable,
    wow64_gl_glDisableClientState,
    wow64_gl_glDrawArrays,
    wow64_gl_glDrawBuffer,
    wow64_gl_glDrawElements,
    wow64_gl_glDrawPixels,
    wow64_gl_glEdgeFlag,
    wow64_gl_glEdgeFlagPointer,
    wow64_gl_glEdgeFlagv,
    wow64_gl_glEnable,
    wow64_gl_glEnableClientState,
    wow64_gl_glEnd,
    wow64_gl_glEndList,
    wow64_gl_glEvalCoord1d,
    wow64_gl_glEvalCoord1dv,
    wow64_gl_glEvalCoord1f,
    wow64_gl_glEvalCoord1fv,
    wow64_gl_glEvalCoord2d,
    wow64_gl_glEvalCoord2dv,
    wow64_gl_glEvalCoord2f,
    wow64_gl_glEvalCoord2fv,
    wow64_gl_glEvalMesh1,
    wow64_gl_glEvalMesh2,
    wow64_gl_glEvalPoint1,
    wow64_gl_glEvalPoint2,
    wow64_gl_glFeedbackBuffer,
    wow64_gl_glFinish,
    wow64_gl_glFlush,
    wow64_gl_glFogf,
    wow64_gl_glFogfv,
    wow64_gl_glFogi,
    wow64_gl_glFogiv,
    wow64_gl_glFrontFace,
    wow64_gl_glFrustum,
    wow64_gl_glGenLists,
    wow64_gl_glGenTextures,
    wow64_gl_glGetBooleanv,
    wow64_gl_glGetClipPlane,
    wow64_gl_glGetDoublev,
    wow64_gl_glGetError,
    wow64_gl_glGetFloatv,
    wow64_gl_glGetIntegerv,
    wow64_gl_glGetLightfv,
    wow64_gl_glGetLightiv,
    wow64_gl_glGetMapdv,
    wow64_gl_glGetMapfv,
    wow64_gl_glGetMapiv,
    wow64_gl_glGetMaterialfv,
    wow64_gl_glGetMaterialiv,
    wow64_gl_glGetPixelMapfv,
    wow64_gl_glGetPixelMapuiv,
    wow64_gl_glGetPixelMapusv,
    wow64_gl_glGetPointerv,
    wow64_gl_glGetPolygonStipple,
    wow64_gl_glGetString,
    wow64_gl_glGetTexEnvfv,
    wow64_gl_glGetTexEnviv,
    wow64_gl_glGetTexGendv,
    wow64_gl_glGetTexGenfv,
    wow64_gl_glGetTexGeniv,
    wow64_gl_glGetTexImage,
    wow64_gl_glGetTexLevelParameterfv,
    wow64_gl_glGetTexLevelParameteriv,
    wow64_gl_glGetTexParameterfv,
    wow64_gl_glGetTexParameteriv,
    wow64_gl_glHint,
    wow64_gl_glIndexMask,
    wow64_gl_glIndexPointer,
    wow64_gl_glIndexd,
    wow64_gl_glIndexdv,
    wow64_gl_glIndexf,
    wow64_gl_glIndexfv,
    wow64_gl_glIndexi,
    wow64_gl_glIndexiv,
    wow64_gl_glIndexs,
    wow64_gl_glIndexsv,
    wow64_gl_glIndexub,
    wow64_gl_glIndexubv,
    wow64_gl_glInitNames,
    wow64_gl_glInterleavedArrays,
    wow64_gl_glIsEnabled,
    wow64_gl_glIsList,
    wow64_gl_glIsTexture,
    wow64_gl_glLightModelf,
    wow64_gl_glLightModelfv,
    wow64_gl_glLightModeli,
    wow64_gl_glLightModeliv,
    wow64_gl_glLightf,
    wow64_gl_glLightfv,
    wow64_gl_glLighti,
    wow64_gl_glLightiv,
    wow64_gl_glLineStipple,
    wow64_gl_glLineWidth,
    wow64_gl_glListBase,
    wow64_gl_glLoadIdentity,
    wow64_gl_glLoadMatrixd,
    wow64_gl_glLoadMatrixf,
    wow64_gl_glLoadName,
    wow64_gl_glLogicOp,
    wow64_gl_glMap1d,
    wow64_gl_glMap1f,
    wow64_gl_glMap2d,
    wow64_gl_glMap2f,
    wow64_gl_glMapGrid1d,
    wow64_gl_glMapGrid1f,
    wow64_gl_glMapGrid2d,
    wow64_gl_glMapGrid2f,
    wow64_gl_glMaterialf,
    wow64_gl_glMaterialfv,
    wow64_gl_glMateriali,
    wow64_gl_glMaterialiv,
    wow64_gl_glMatrixMode,
    wow64_gl_glMultMatrixd,
    wow64_gl_glMultMatrixf,
    wow64_gl_glNewList,
    wow64_gl_glNormal3b,
    wow64_gl_glNormal3bv,
    wow64_gl_glNormal3d,
    wow64_gl_glNormal3dv,
    wow64_gl_glNormal3f,
    wow64_gl_glNormal3fv,
    wow64_gl_glNormal3i,
    wow64_gl_glNormal3iv,
    wow64_gl_glNormal3s,
    wow64_gl_glNormal3sv,
    wow64_gl_glNormalPointer,
    wow64_gl_glOrtho,
    wow64_gl_glPassThrough,
    wow64_gl_glPixelMapfv,
    wow64_gl_glPixelMapuiv,
    wow64_gl_glPixelMapusv,
    wow64_gl_glPixelStoref,
    wow64_gl_glPixelStorei,
    wow64_gl_glPixelTransferf,
    wow64_gl_glPixelTransferi,
    wow64_gl_glPixelZoom,
    wow64_gl_glPointSize,
    wow64_gl_glPolygonMode,
    wow64_gl_glPolygonOffset,
    wow64_gl_glPolygonStipple,
    wow64_gl_glPopAttrib,
    wow64_gl_glPopClientAttrib,
    wow64_gl_glPopMatrix,
    wow64_gl_glPopName,
    wow64_gl_glPrioritizeTextures,
    wow64_gl_glPushAttrib,
    wow64_gl_glPushClientAttrib,
    wow64_gl_glPushMatrix,
    wow64_gl_glPushName,
    wow64_gl_glRasterPos2d,
    wow64_gl_glRasterPos2dv,
    wow64_gl_glRasterPos2f,
    wow64_gl_glRasterPos2fv,
    wow64_gl_glRasterPos2i,
    wow64_gl_glRasterPos2iv,
    wow64_gl_glRasterPos2s,
    wow64_gl_glRasterPos2sv,
    wow64_gl_glRasterPos3d,
    wow64_gl_glRasterPos3dv,
    wow64_gl_glRasterPos3f,
    wow64_gl_glRasterPos3fv,
    wow64_gl_glRasterPos3i,
    wow64_gl_glRasterPos3iv,
    wow64_gl_glRasterPos3s,
    wow64_gl_glRasterPos3sv,
    wow64_gl_glRasterPos4d,
    wow64_gl_glRasterPos4dv,
    wow64_gl_glRasterPos4f,
    wow64_gl_glRasterPos4fv,
    wow64_gl_glRasterPos4i,
    wow64_gl_glRasterPos4iv,
    wow64_gl_glRasterPos4s,
    wow64_gl_glRasterPos4sv,
    wow64_gl_glReadBuffer,
    wow64_gl_glReadPixels,
    wow64_gl_glRectd,
    wow64_gl_glRectdv,
    wow64_gl_glRectf,
    wow64_gl_glRectfv,
    wow64_gl_glRecti,
    wow64_gl_glRectiv,
    wow64_gl_glRects,
    wow64_gl_glRectsv,
    wow64_gl_glRenderMode,
    wow64_gl_glRotated,
    wow64_gl_glRotatef,
    wow64_gl_glScaled,
    wow64_gl_glScalef,
    wow64_gl_glScissor,
    wow64_gl_glSelectBuffer,
    wow64_gl_glShadeModel,
    wow64_gl_glStencilFunc,
    wow64_gl_glStencilMask,
    wow64_gl_glStencilOp,
    wow64_gl_glTexCoord1d,
    wow64_gl_glTexCoord1dv,
    wow64_gl_glTexCoord1f,
    wow64_gl_glTexCoord1fv,
    wow64_gl_glTexCoord1i,
    wow64_gl_glTexCoord1iv,
    wow64_gl_glTexCoord1s,
    wow64_gl_glTexCoord1sv,
    wow64_gl_glTexCoord2d,
    wow64_gl_glTexCoord2dv,
    wow64_gl_glTexCoord2f,
    wow64_gl_glTexCoord2fv,
    wow64_gl_glTexCoord2i,
    wow64_gl_glTexCoord2iv,
    wow64_gl_glTexCoord2s,
    wow64_gl_glTexCoord2sv,
    wow64_gl_glTexCoord3d,
    wow64_gl_glTexCoord3dv,
    wow64_gl_glTexCoord3f,
    wow64_gl_glTexCoord3fv,
    wow64_gl_glTexCoord3i,
    wow64_gl_glTexCoord3iv,
    wow64_gl_glTexCoord3s,
    wow64_gl_glTexCoord3sv,
    wow64_gl_glTexCoord4d,
    wow64_gl_glTexCoord4dv,
    wow64_gl_glTexCoord4f,
    wow64_gl_glTexCoord4fv,
    wow64_gl_glTexCoord4i,
    wow64_gl_glTexCoord4iv,
    wow64_gl_glTexCoord4s,
    wow64_gl_glTexCoord4sv,
    wow64_gl_glTexCoordPointer,
    wow64_gl_glTexEnvf,
    wow64_gl_glTexEnvfv,
    wow64_gl_glTexEnvi,
    wow64_gl_glTexEnviv,
    wow64_gl_glTexGend,
    wow64_gl_glTexGendv,
    wow64_gl_glTexGenf,
    wow64_gl_glTexGenfv,
    wow64_gl_glTexGeni,
    wow64_gl_glTexGeniv,
    wow64_gl_glTexImage1D,
    wow64_gl_glTexImage2D,
    wow64_gl_glTexParameterf,
    wow64_gl_glTexParameterfv,
    wow64_gl_glTexParameteri,
    wow64_gl_glTexParameteriv,
    wow64_gl_glTexSubImage1D,
    wow64_gl_glTexSubImage2D,
    wow64_gl_glTranslated,
    wow64_gl_glTranslatef,
    wow64_gl_glVertex2d,
    wow64_gl_glVertex2dv,
    wow64_gl_glVertex2f,
    wow64_gl_glVertex2fv,
    wow64_gl_glVertex2i,
    wow64_gl_glVertex2iv,
    wow64_gl_glVertex2s,
    wow64_gl_glVertex2sv,
    wow64_gl_glVertex3d,
    wow64_gl_glVertex3dv,
    wow64_gl_glVertex3f,
    wow64_gl_glVertex3fv,
    wow64_gl_glVertex3i,
    wow64_gl_glVertex3iv,
    wow64_gl_glVertex3s,
    wow64_gl_glVertex3sv,
    wow64_gl_glVertex4d,
    wow64_gl_glVertex4dv,
    wow64_gl_glVertex4f,
    wow64_gl_glVertex4fv,
    wow64_gl_glVertex4i,
    wow64_gl_glVertex4iv,
    wow64_gl_glVertex4s,
    wow64_gl_glVertex4sv,
    wow64_gl_glVertexPointer,
    wow64_gl_glViewport,
    wow64_ext_glAccumxOES,
    wow64_ext_glAcquireKeyedMutexWin32EXT,
    wow64_ext_glActiveProgramEXT,
    wow64_ext_glActiveShaderProgram,
    wow64_ext_glActiveStencilFaceEXT,
    wow64_ext_glActiveTexture,
    wow64_ext_glActiveTextureARB,
    wow64_ext_glActiveVaryingNV,
    wow64_ext_glAlphaFragmentOp1ATI,
    wow64_ext_glAlphaFragmentOp2ATI,
    wow64_ext_glAlphaFragmentOp3ATI,
    wow64_ext_glAlphaFuncx,
    wow64_ext_glAlphaFuncxOES,
    wow64_ext_glAlphaToCoverageDitherControlNV,
    wow64_ext_glApplyFramebufferAttachmentCMAAINTEL,
    wow64_ext_glApplyTextureEXT,
    wow64_ext_glAreProgramsResidentNV,
    wow64_ext_glAreTexturesResidentEXT,
    wow64_ext_glArrayElementEXT,
    wow64_ext_glArrayObjectATI,
    wow64_ext_glAsyncCopyBufferSubDataNVX,
    wow64_ext_glAsyncCopyImageSubDataNVX,
    wow64_ext_glAsyncMarkerSGIX,
    wow64_ext_glAttachObjectARB,
    wow64_ext_glAttachShader,
    wow64_ext_glBeginConditionalRender,
    wow64_ext_glBeginConditionalRenderNV,
    wow64_ext_glBeginConditionalRenderNVX,
    wow64_ext_glBeginFragmentShaderATI,
    wow64_ext_glBeginOcclusionQueryNV,
    wow64_ext_glBeginPerfMonitorAMD,
    wow64_ext_glBeginPerfQueryINTEL,
    wow64_ext_glBeginQuery,
    wow64_ext_glBeginQueryARB,
    wow64_ext_glBeginQueryIndexed,
    wow64_ext_glBeginTransformFeedback,
    wow64_ext_glBeginTransformFeedbackEXT,
    wow64_ext_glBeginTransformFeedbackNV,
    wow64_ext_glBeginVertexShaderEXT,
    wow64_ext_glBeginVideoCaptureNV,
    wow64_ext_glBindAttribLocation,
    wow64_ext_glBindAttribLocationARB,
    wow64_ext_glBindBuffer,
    wow64_ext_glBindBufferARB,
    wow64_ext_glBindBufferBase,
    wow64_ext_glBindBufferBaseEXT,
    wow64_ext_glBindBufferBaseNV,
    wow64_ext_glBindBufferOffsetEXT,
    wow64_ext_glBindBufferOffsetNV,
    wow64_ext_glBindBufferRange,
    wow64_ext_glBindBufferRangeEXT,
    wow64_ext_glBindBufferRangeNV,
    wow64_ext_glBindBuffersBase,
    wow64_ext_glBindBuffersRange,
    wow64_ext_glBindFragDataLocation,
    wow64_ext_glBindFragDataLocationEXT,
    wow64_ext_glBindFragDataLocationIndexed,
    wow64_ext_glBindFragmentShaderATI,
    wow64_ext_glBindFramebuffer,
    wow64_ext_glBindFramebufferEXT,
    wow64_ext_glBindImageTexture,
    wow64_ext_glBindImageTextureEXT,
    wow64_ext_glBindImageTextures,
    wow64_ext_glBindLightParameterEXT,
    wow64_ext_glBindMaterialParameterEXT,
    wow64_ext_glBindMultiTextureEXT,
    wow64_ext_glBindParameterEXT,
    wow64_ext_glBindProgramARB,
    wow64_ext_glBindProgramNV,
    wow64_ext_glBindProgramPipeline,
    wow64_ext_glBindRenderbuffer,
    wow64_ext_glBindRenderbufferEXT,
    wow64_ext_glBindSampler,
    wow64_ext_glBindSamplers,
    wow64_ext_glBindShadingRateImageNV,
    wow64_ext_glBindTexGenParameterEXT,
    wow64_ext_glBindTextureEXT,
    wow64_ext_glBindTextureUnit,
    wow64_ext_glBindTextureUnitParameterEXT,
    wow64_ext_glBindTextures,
    wow64_ext_glBindTransformFeedback,
    wow64_ext_glBindTransformFeedbackNV,
    wow64_ext_glBindVertexArray,
    wow64_ext_glBindVertexArrayAPPLE,
    wow64_ext_glBindVertexBuffer,
    wow64_ext_glBindVertexBuffers,
    wow64_ext_glBindVertexShaderEXT,
    wow64_ext_glBindVideoCaptureStreamBufferNV,
    wow64_ext_glBindVideoCaptureStreamTextureNV,
    wow64_ext_glBinormal3bEXT,
    wow64_ext_glBinormal3bvEXT,
    wow64_ext_glBinormal3dEXT,
    wow64_ext_glBinormal3dvEXT,
    wow64_ext_glBinormal3fEXT,
    wow64_ext_glBinormal3fvEXT,
    wow64_ext_glBinormal3iEXT,
    wow64_ext_glBinormal3ivEXT,
    wow64_ext_glBinormal3sEXT,
    wow64_ext_glBinormal3svEXT,
    wow64_ext_glBinormalPointerEXT,
    wow64_ext_glBitmapxOES,
    wow64_ext_glBlendBarrier,
    wow64_ext_glBlendBarrierKHR,
    wow64_ext_glBlendBarrierNV,
    wow64_ext_glBlendColor,
    wow64_ext_glBlendColorEXT,
    wow64_ext_glBlendColorxOES,
    wow64_ext_glBlendEquation,
    wow64_ext_glBlendEquationEXT,
    wow64_ext_glBlendEquationIndexedAMD,
    wow64_ext_glBlendEquationSeparate,
    wow64_ext_glBlendEquationSeparateEXT,
    wow64_ext_glBlendEquationSeparateIndexedAMD,
    wow64_ext_glBlendEquationSeparatei,
    wow64_ext_glBlendEquationSeparateiARB,
    wow64_ext_glBlendEquationi,
    wow64_ext_glBlendEquationiARB,
    wow64_ext_glBlendFuncIndexedAMD,
    wow64_ext_glBlendFuncSeparate,
    wow64_ext_glBlendFuncSeparateEXT,
    wow64_ext_glBlendFuncSeparateINGR,
    wow64_ext_glBlendFuncSeparateIndexedAMD,
    wow64_ext_glBlendFuncSeparatei,
    wow64_ext_glBlendFuncSeparateiARB,
    wow64_ext_glBlendFunci,
    wow64_ext_glBlendFunciARB,
    wow64_ext_glBlendParameteriNV,
    wow64_ext_glBlitFramebuffer,
    wow64_ext_glBlitFramebufferEXT,
    wow64_ext_glBlitFramebufferLayerEXT,
    wow64_ext_glBlitFramebufferLayersEXT,
    wow64_ext_glBlitNamedFramebuffer,
    wow64_ext_glBufferAddressRangeNV,
    wow64_ext_glBufferAttachMemoryNV,
    wow64_ext_glBufferData,
    wow64_ext_glBufferDataARB,
    wow64_ext_glBufferPageCommitmentARB,
    wow64_ext_glBufferPageCommitmentMemNV,
    wow64_ext_glBufferParameteriAPPLE,
    wow64_ext_glBufferRegionEnabled,
    wow64_ext_glBufferStorage,
    wow64_ext_glBufferStorageMemEXT,
    wow64_ext_glBufferSubData,
    wow64_ext_glBufferSubDataARB,
    wow64_ext_glCallCommandListNV,
    wow64_ext_glCheckFramebufferStatus,
    wow64_ext_glCheckFramebufferStatusEXT,
    wow64_ext_glCheckNamedFramebufferStatus,
    wow64_ext_glCheckNamedFramebufferStatusEXT,
    wow64_ext_glClampColor,
    wow64_ext_glClampColorARB,
    wow64_ext_glClearAccumxOES,
    wow64_ext_glClearBufferData,
    wow64_ext_glClearBufferSubData,
    wow64_ext_glClearBufferfi,
    wow64_ext_glClearBufferfv,
    wow64_ext_glClearBufferiv,
    wow64_ext_glClearBufferuiv,
    wow64_ext_glClearColorIiEXT,
    wow64_ext_glClearColorIuiEXT,
    wow64_ext_glClearColorx,
    wow64_ext_glClearColorxOES,
    wow64_ext_glClearDepthdNV,
    wow64_ext_glClearDepthf,
    wow64_ext_glClearDepthfOES,
    wow64_ext_glClearDepthx,
    wow64_ext_glClearDepthxOES,
    wow64_ext_glClearNamedBufferData,
    wow64_ext_glClearNamedBufferDataEXT,
    wow64_ext_glClearNamedBufferSubData,
    wow64_ext_glClearNamedBufferSubDataEXT,
    wow64_ext_glClearNamedFramebufferfi,
    wow64_ext_glClearNamedFramebufferfv,
    wow64_ext_glClearNamedFramebufferiv,
    wow64_ext_glClearNamedFramebufferuiv,
    wow64_ext_glClearTexImage,
    wow64_ext_glClearTexSubImage,
    wow64_ext_glClientActiveTexture,
    wow64_ext_glClientActiveTextureARB,
    wow64_ext_glClientActiveVertexStreamATI,
    wow64_ext_glClientAttribDefaultEXT,
    wow64_ext_glClientWaitSemaphoreui64NVX,
    wow64_ext_glClientWaitSync,
    wow64_ext_glClipControl,
    wow64_ext_glClipPlanef,
    wow64_ext_glClipPlanefOES,
    wow64_ext_glClipPlanex,
    wow64_ext_glClipPlanexOES,
    wow64_ext_glColor3fVertex3fSUN,
    wow64_ext_glColor3fVertex3fvSUN,
    wow64_ext_glColor3hNV,
    wow64_ext_glColor3hvNV,
    wow64_ext_glColor3xOES,
    wow64_ext_glColor3xvOES,
    wow64_ext_glColor4fNormal3fVertex3fSUN,
    wow64_ext_glColor4fNormal3fVertex3fvSUN,
    wow64_ext_glColor4hNV,
    wow64_ext_glColor4hvNV,
    wow64_ext_glColor4ubVertex2fSUN,
    wow64_ext_glColor4ubVertex2fvSUN,
    wow64_ext_glColor4ubVertex3fSUN,
    wow64_ext_glColor4ubVertex3fvSUN,
    wow64_ext_glColor4x,
    wow64_ext_glColor4xOES,
    wow64_ext_glColor4xvOES,
    wow64_ext_glColorFormatNV,
    wow64_ext_glColorFragmentOp1ATI,
    wow64_ext_glColorFragmentOp2ATI,
    wow64_ext_glColorFragmentOp3ATI,
    wow64_ext_glColorMaskIndexedEXT,
    wow64_ext_glColorMaski,
    wow64_ext_glColorP3ui,
    wow64_ext_glColorP3uiv,
    wow64_ext_glColorP4ui,
    wow64_ext_glColorP4uiv,
    wow64_ext_glColorPointerEXT,
    wow64_ext_glColorPointerListIBM,
    wow64_ext_glColorPointervINTEL,
    wow64_ext_glColorSubTable,
    wow64_ext_glColorSubTableEXT,
    wow64_ext_glColorTable,
    wow64_ext_glColorTableEXT,
    wow64_ext_glColorTableParameterfv,
    wow64_ext_glColorTableParameterfvSGI,
    wow64_ext_glColorTableParameteriv,
    wow64_ext_glColorTableParameterivSGI,
    wow64_ext_glColorTableSGI,
    wow64_ext_glCombinerInputNV,
    wow64_ext_glCombinerOutputNV,
    wow64_ext_glCombinerParameterfNV,
    wow64_ext_glCombinerParameterfvNV,
    wow64_ext_glCombinerParameteriNV,
    wow64_ext_glCombinerParameterivNV,
    wow64_ext_glCombinerStageParameterfvNV,
    wow64_ext_glCommandListSegmentsNV,
    wow64_ext_glCompileCommandListNV,
    wow64_ext_glCompileShader,
    wow64_ext_glCompileShaderARB,
    wow64_ext_glCompileShaderIncludeARB,
    wow64_ext_glCompressedMultiTexImage1DEXT,
    wow64_ext_glCompressedMultiTexImage2DEXT,
    wow64_ext_glCompressedMultiTexImage3DEXT,
    wow64_ext_glCompressedMultiTexSubImage1DEXT,
    wow64_ext_glCompressedMultiTexSubImage2DEXT,
    wow64_ext_glCompressedMultiTexSubImage3DEXT,
    wow64_ext_glCompressedTexImage1D,
    wow64_ext_glCompressedTexImage1DARB,
    wow64_ext_glCompressedTexImage2D,
    wow64_ext_glCompressedTexImage2DARB,
    wow64_ext_glCompressedTexImage3D,
    wow64_ext_glCompressedTexImage3DARB,
    wow64_ext_glCompressedTexSubImage1D,
    wow64_ext_glCompressedTexSubImage1DARB,
    wow64_ext_glCompressedTexSubImage2D,
    wow64_ext_glCompressedTexSubImage2DARB,
    wow64_ext_glCompressedTexSubImage3D,
    wow64_ext_glCompressedTexSubImage3DARB,
    wow64_ext_glCompressedTextureImage1DEXT,
    wow64_ext_glCompressedTextureImage2DEXT,
    wow64_ext_glCompressedTextureImage3DEXT,
    wow64_ext_glCompressedTextureSubImage1D,
    wow64_ext_glCompressedTextureSubImage1DEXT,
    wow64_ext_glCompressedTextureSubImage2D,
    wow64_ext_glCompressedTextureSubImage2DEXT,
    wow64_ext_glCompressedTextureSubImage3D,
    wow64_ext_glCompressedTextureSubImage3DEXT,
    wow64_ext_glConservativeRasterParameterfNV,
    wow64_ext_glConservativeRasterParameteriNV,
    wow64_ext_glConvolutionFilter1D,
    wow64_ext_glConvolutionFilter1DEXT,
    wow64_ext_glConvolutionFilter2D,
    wow64_ext_glConvolutionFilter2DEXT,
    wow64_ext_glConvolutionParameterf,
    wow64_ext_glConvolutionParameterfEXT,
    wow64_ext_glConvolutionParameterfv,
    wow64_ext_glConvolutionParameterfvEXT,
    wow64_ext_glConvolutionParameteri,
    wow64_ext_glConvolutionParameteriEXT,
    wow64_ext_glConvolutionParameteriv,
    wow64_ext_glConvolutionParameterivEXT,
    wow64_ext_glConvolutionParameterxOES,
    wow64_ext_glConvolutionParameterxvOES,
    wow64_ext_glCopyBufferSubData,
    wow64_ext_glCopyColorSubTable,
    wow64_ext_glCopyColorSubTableEXT,
    wow64_ext_glCopyColorTable,
    wow64_ext_glCopyColorTableSGI,
    wow64_ext_glCopyConvolutionFilter1D,
    wow64_ext_glCopyConvolutionFilter1DEXT,
    wow64_ext_glCopyConvolutionFilter2D,
    wow64_ext_glCopyConvolutionFilter2DEXT,
    wow64_ext_glCopyImageSubData,
    wow64_ext_glCopyImageSubDataNV,
    wow64_ext_glCopyMultiTexImage1DEXT,
    wow64_ext_glCopyMultiTexImage2DEXT,
    wow64_ext_glCopyMultiTexSubImage1DEXT,
    wow64_ext_glCopyMultiTexSubImage2DEXT,
    wow64_ext_glCopyMultiTexSubImage3DEXT,
    wow64_ext_glCopyNamedBufferSubData,
    wow64_ext_glCopyPathNV,
    wow64_ext_glCopyTexImage1DEXT,
    wow64_ext_glCopyTexImage2DEXT,
    wow64_ext_glCopyTexSubImage1DEXT,
    wow64_ext_glCopyTexSubImage2DEXT,
    wow64_ext_glCopyTexSubImage3D,
    wow64_ext_glCopyTexSubImage3DEXT,
    wow64_ext_glCopyTextureImage1DEXT,
    wow64_ext_glCopyTextureImage2DEXT,
    wow64_ext_glCopyTextureSubImage1D,
    wow64_ext_glCopyTextureSubImage1DEXT,
    wow64_ext_glCopyTextureSubImage2D,
    wow64_ext_glCopyTextureSubImage2DEXT,
    wow64_ext_glCopyTextureSubImage3D,
    wow64_ext_glCopyTextureSubImage3DEXT,
    wow64_ext_glCoverFillPathInstancedNV,
    wow64_ext_glCoverFillPathNV,
    wow64_ext_glCoverStrokePathInstancedNV,
    wow64_ext_glCoverStrokePathNV,
    wow64_ext_glCoverageModulationNV,
    wow64_ext_glCoverageModulationTableNV,
    wow64_ext_glCreateBuffers,
    wow64_ext_glCreateCommandListsNV,
    wow64_ext_glCreateFramebuffers,
    wow64_ext_glCreateMemoryObjectsEXT,
    wow64_ext_glCreatePerfQueryINTEL,
    wow64_ext_glCreateProgram,
    wow64_ext_glCreateProgramObjectARB,
    wow64_ext_glCreateProgramPipelines,
    wow64_ext_glCreateProgressFenceNVX,
    wow64_ext_glCreateQueries,
    wow64_ext_glCreateRenderbuffers,
    wow64_ext_glCreateSamplers,
    wow64_ext_glCreateSemaphoresNV,
    wow64_ext_glCreateShader,
    wow64_ext_glCreateShaderObjectARB,
    wow64_ext_glCreateShaderProgramEXT,
    wow64_ext_glCreateShaderProgramv,
    wow64_ext_glCreateStatesNV,
    wow64_ext_glCreateSyncFromCLeventARB,
    wow64_ext_glCreateTextures,
    wow64_ext_glCreateTransformFeedbacks,
    wow64_ext_glCreateVertexArrays,
    wow64_ext_glCullParameterdvEXT,
    wow64_ext_glCullParameterfvEXT,
    wow64_ext_glCurrentPaletteMatrixARB,
    wow64_ext_glDebugMessageCallback,
    wow64_ext_glDebugMessageCallbackAMD,
    wow64_ext_glDebugMessageCallbackARB,
    wow64_ext_glDebugMessageControl,
    wow64_ext_glDebugMessageControlARB,
    wow64_ext_glDebugMessageEnableAMD,
    wow64_ext_glDebugMessageInsert,
    wow64_ext_glDebugMessageInsertAMD,
    wow64_ext_glDebugMessageInsertARB,
    wow64_ext_glDeformSGIX,
    wow64_ext_glDeformationMap3dSGIX,
    wow64_ext_glDeformationMap3fSGIX,
    wow64_ext_glDeleteAsyncMarkersSGIX,
    wow64_ext_glDeleteBufferRegion,
    wow64_ext_glDeleteBuffers,
    wow64_ext_glDeleteBuffersARB,
    wow64_ext_glDeleteCommandListsNV,
    wow64_ext_glDeleteFencesAPPLE,
    wow64_ext_glDeleteFencesNV,
    wow64_ext_glDeleteFragmentShaderATI,
    wow64_ext_glDeleteFramebuffers,
    wow64_ext_glDeleteFramebuffersEXT,
    wow64_ext_glDeleteMemoryObjectsEXT,
    wow64_ext_glDeleteNamedStringARB,
    wow64_ext_glDeleteNamesAMD,
    wow64_ext_glDeleteObjectARB,
    wow64_ext_glDeleteObjectBufferATI,
    wow64_ext_glDeleteOcclusionQueriesNV,
    wow64_ext_glDeletePathsNV,
    wow64_ext_glDeletePerfMonitorsAMD,
    wow64_ext_glDeletePerfQueryINTEL,
    wow64_ext_glDeleteProgram,
    wow64_ext_glDeleteProgramPipelines,
    wow64_ext_glDeleteProgramsARB,
    wow64_ext_glDeleteProgramsNV,
    wow64_ext_glDeleteQueries,
    wow64_ext_glDeleteQueriesARB,
    wow64_ext_glDeleteQueryResourceTagNV,
    wow64_ext_glDeleteRenderbuffers,
    wow64_ext_glDeleteRenderbuffersEXT,
    wow64_ext_glDeleteSamplers,
    wow64_ext_glDeleteSemaphoresEXT,
    wow64_ext_glDeleteShader,
    wow64_ext_glDeleteStatesNV,
    wow64_ext_glDeleteSync,
    wow64_ext_glDeleteTexturesEXT,
    wow64_ext_glDeleteTransformFeedbacks,
    wow64_ext_glDeleteTransformFeedbacksNV,
    wow64_ext_glDeleteVertexArrays,
    wow64_ext_glDeleteVertexArraysAPPLE,
    wow64_ext_glDeleteVertexShaderEXT,
    wow64_ext_glDepthBoundsEXT,
    wow64_ext_glDepthBoundsdNV,
    wow64_ext_glDepthRangeArraydvNV,
    wow64_ext_glDepthRangeArrayv,
    wow64_ext_glDepthRangeIndexed,
    wow64_ext_glDepthRangeIndexeddNV,
    wow64_ext_glDepthRangedNV,
    wow64_ext_glDepthRangef,
    wow64_ext_glDepthRangefOES,
    wow64_ext_glDepthRangex,
    wow64_ext_glDepthRangexOES,
    wow64_ext_glDetachObjectARB,
    wow64_ext_glDetachShader,
    wow64_ext_glDetailTexFuncSGIS,
    wow64_ext_glDisableClientStateIndexedEXT,
    wow64_ext_glDisableClientStateiEXT,
    wow64_ext_glDisableIndexedEXT,
    wow64_ext_glDisableVariantClientStateEXT,
    wow64_ext_glDisableVertexArrayAttrib,
    wow64_ext_glDisableVertexArrayAttribEXT,
    wow64_ext_glDisableVertexArrayEXT,
    wow64_ext_glDisableVertexAttribAPPLE,
    wow64_ext_glDisableVertexAttribArray,
    wow64_ext_glDisableVertexAttribArrayARB,
    wow64_ext_glDisablei,
    wow64_ext_glDispatchCompute,
    wow64_ext_glDispatchComputeGroupSizeARB,
    wow64_ext_glDispatchComputeIndirect,
    wow64_ext_glDrawArraysEXT,
    wow64_ext_glDrawArraysIndirect,
    wow64_ext_glDrawArraysInstanced,
    wow64_ext_glDrawArraysInstancedARB,
    wow64_ext_glDrawArraysInstancedBaseInstance,
    wow64_ext_glDrawArraysInstancedEXT,
    wow64_ext_glDrawBufferRegion,
    wow64_ext_glDrawBuffers,
    wow64_ext_glDrawBuffersARB,
    wow64_ext_glDrawBuffersATI,
    wow64_ext_glDrawCommandsAddressNV,
    wow64_ext_glDrawCommandsNV,
    wow64_ext_glDrawCommandsStatesAddressNV,
    wow64_ext_glDrawCommandsStatesNV,
    wow64_ext_glDrawElementArrayAPPLE,
    wow64_ext_glDrawElementArrayATI,
    wow64_ext_glDrawElementsBaseVertex,
    wow64_ext_glDrawElementsIndirect,
    wow64_ext_glDrawElementsInstanced,
    wow64_ext_glDrawElementsInstancedARB,
    wow64_ext_glDrawElementsInstancedBaseInstance,
    wow64_ext_glDrawElementsInstancedBaseVertex,
    wow64_ext_glDrawElementsInstancedBaseVertexBaseInstance,
    wow64_ext_glDrawElementsInstancedEXT,
    wow64_ext_glDrawMeshArraysSUN,
    wow64_ext_glDrawMeshTasksEXT,
    wow64_ext_glDrawMeshTasksIndirectEXT,
    wow64_ext_glDrawMeshTasksIndirectNV,
    wow64_ext_glDrawMeshTasksNV,
    wow64_ext_glDrawRangeElementArrayAPPLE,
    wow64_ext_glDrawRangeElementArrayATI,
    wow64_ext_glDrawRangeElements,
    wow64_ext_glDrawRangeElementsBaseVertex,
    wow64_ext_glDrawRangeElementsEXT,
    wow64_ext_glDrawTextureNV,
    wow64_ext_glDrawTransformFeedback,
    wow64_ext_glDrawTransformFeedbackInstanced,
    wow64_ext_glDrawTransformFeedbackNV,
    wow64_ext_glDrawTransformFeedbackStream,
    wow64_ext_glDrawTransformFeedbackStreamInstanced,
    wow64_ext_glDrawVkImageNV,
    wow64_ext_glEGLImageTargetTexStorageEXT,
    wow64_ext_glEGLImageTargetTextureStorageEXT,
    wow64_ext_glEdgeFlagFormatNV,
    wow64_ext_glEdgeFlagPointerEXT,
    wow64_ext_glEdgeFlagPointerListIBM,
    wow64_ext_glElementPointerAPPLE,
    wow64_ext_glElementPointerATI,
    wow64_ext_glEnableClientStateIndexedEXT,
    wow64_ext_glEnableClientStateiEXT,
    wow64_ext_glEnableIndexedEXT,
    wow64_ext_glEnableVariantClientStateEXT,
    wow64_ext_glEnableVertexArrayAttrib,
    wow64_ext_glEnableVertexArrayAttribEXT,
    wow64_ext_glEnableVertexArrayEXT,
    wow64_ext_glEnableVertexAttribAPPLE,
    wow64_ext_glEnableVertexAttribArray,
    wow64_ext_glEnableVertexAttribArrayARB,
    wow64_ext_glEnablei,
    wow64_ext_glEndConditionalRender,
    wow64_ext_glEndConditionalRenderNV,
    wow64_ext_glEndConditionalRenderNVX,
    wow64_ext_glEndFragmentShaderATI,
    wow64_ext_glEndOcclusionQueryNV,
    wow64_ext_glEndPerfMonitorAMD,
    wow64_ext_glEndPerfQueryINTEL,
    wow64_ext_glEndQuery,
    wow64_ext_glEndQueryARB,
    wow64_ext_glEndQueryIndexed,
    wow64_ext_glEndTransformFeedback,
    wow64_ext_glEndTransformFeedbackEXT,
    wow64_ext_glEndTransformFeedbackNV,
    wow64_ext_glEndVertexShaderEXT,
    wow64_ext_glEndVideoCaptureNV,
    wow64_ext_glEvalCoord1xOES,
    wow64_ext_glEvalCoord1xvOES,
    wow64_ext_glEvalCoord2xOES,
    wow64_ext_glEvalCoord2xvOES,
    wow64_ext_glEvalMapsNV,
    wow64_ext_glEvaluateDepthValuesARB,
    wow64_ext_glExecuteProgramNV,
    wow64_ext_glExtractComponentEXT,
    wow64_ext_glFeedbackBufferxOES,
    wow64_ext_glFenceSync,
    wow64_ext_glFinalCombinerInputNV,
    wow64_ext_glFinishAsyncSGIX,
    wow64_ext_glFinishFenceAPPLE,
    wow64_ext_glFinishFenceNV,
    wow64_ext_glFinishObjectAPPLE,
    wow64_ext_glFinishTextureSUNX,
    wow64_ext_glFlushMappedBufferRange,
    wow64_ext_glFlushMappedBufferRangeAPPLE,
    wow64_ext_glFlushMappedNamedBufferRange,
    wow64_ext_glFlushMappedNamedBufferRangeEXT,
    wow64_ext_glFlushPixelDataRangeNV,
    wow64_ext_glFlushRasterSGIX,
    wow64_ext_glFlushStaticDataIBM,
    wow64_ext_glFlushVertexArrayRangeAPPLE,
    wow64_ext_glFlushVertexArrayRangeNV,
    wow64_ext_glFogCoordFormatNV,
    wow64_ext_glFogCoordPointer,
    wow64_ext_glFogCoordPointerEXT,
    wow64_ext_glFogCoordPointerListIBM,
    wow64_ext_glFogCoordd,
    wow64_ext_glFogCoorddEXT,
    wow64_ext_glFogCoorddv,
    wow64_ext_glFogCoorddvEXT,
    wow64_ext_glFogCoordf,
    wow64_ext_glFogCoordfEXT,
    wow64_ext_glFogCoordfv,
    wow64_ext_glFogCoordfvEXT,
    wow64_ext_glFogCoordhNV,
    wow64_ext_glFogCoordhvNV,
    wow64_ext_glFogFuncSGIS,
    wow64_ext_glFogx,
    wow64_ext_glFogxOES,
    wow64_ext_glFogxv,
    wow64_ext_glFogxvOES,
    wow64_ext_glFragmentColorMaterialSGIX,
    wow64_ext_glFragmentCoverageColorNV,
    wow64_ext_glFragmentLightModelfSGIX,
    wow64_ext_glFragmentLightModelfvSGIX,
    wow64_ext_glFragmentLightModeliSGIX,
    wow64_ext_glFragmentLightModelivSGIX,
    wow64_ext_glFragmentLightfSGIX,
    wow64_ext_glFragmentLightfvSGIX,
    wow64_ext_glFragmentLightiSGIX,
    wow64_ext_glFragmentLightivSGIX,
    wow64_ext_glFragmentMaterialfSGIX,
    wow64_ext_glFragmentMaterialfvSGIX,
    wow64_ext_glFragmentMaterialiSGIX,
    wow64_ext_glFragmentMaterialivSGIX,
    wow64_ext_glFrameTerminatorGREMEDY,
    wow64_ext_glFrameZoomSGIX,
    wow64_ext_glFramebufferDrawBufferEXT,
    wow64_ext_glFramebufferDrawBuffersEXT,
    wow64_ext_glFramebufferFetchBarrierEXT,
    wow64_ext_glFramebufferParameteri,
    wow64_ext_glFramebufferParameteriMESA,
    wow64_ext_glFramebufferReadBufferEXT,
    wow64_ext_glFramebufferRenderbuffer,
    wow64_ext_glFramebufferRenderbufferEXT,
    wow64_ext_glFramebufferSampleLocationsfvARB,
    wow64_ext_glFramebufferSampleLocationsfvNV,
    wow64_ext_glFramebufferSamplePositionsfvAMD,
    wow64_ext_glFramebufferShadingRateEXT,
    wow64_ext_glFramebufferTexture,
    wow64_ext_glFramebufferTexture1D,
    wow64_ext_glFramebufferTexture1DEXT,
    wow64_ext_glFramebufferTexture2D,
    wow64_ext_glFramebufferTexture2DEXT,
    wow64_ext_glFramebufferTexture3D,
    wow64_ext_glFramebufferTexture3DEXT,
    wow64_ext_glFramebufferTextureARB,
    wow64_ext_glFramebufferTextureEXT,
    wow64_ext_glFramebufferTextureFaceARB,
    wow64_ext_glFramebufferTextureFaceEXT,
    wow64_ext_glFramebufferTextureLayer,
    wow64_ext_glFramebufferTextureLayerARB,
    wow64_ext_glFramebufferTextureLayerEXT,
    wow64_ext_glFramebufferTextureMultiviewOVR,
    wow64_ext_glFreeObjectBufferATI,
    wow64_ext_glFrustumf,
    wow64_ext_glFrustumfOES,
    wow64_ext_glFrustumx,
    wow64_ext_glFrustumxOES,
    wow64_ext_glGenAsyncMarkersSGIX,
    wow64_ext_glGenBuffers,
    wow64_ext_glGenBuffersARB,
    wow64_ext_glGenFencesAPPLE,
    wow64_ext_glGenFencesNV,
    wow64_ext_glGenFragmentShadersATI,
    wow64_ext_glGenFramebuffers,
    wow64_ext_glGenFramebuffersEXT,
    wow64_ext_glGenNamesAMD,
    wow64_ext_glGenOcclusionQueriesNV,
    wow64_ext_glGenPathsNV,
    wow64_ext_glGenPerfMonitorsAMD,
    wow64_ext_glGenProgramPipelines,
    wow64_ext_glGenProgramsARB,
    wow64_ext_glGenProgramsNV,
    wow64_ext_glGenQueries,
    wow64_ext_glGenQueriesARB,
    wow64_ext_glGenQueryResourceTagNV,
    wow64_ext_glGenRenderbuffers,
    wow64_ext_glGenRenderbuffersEXT,
    wow64_ext_glGenSamplers,
    wow64_ext_glGenSemaphoresEXT,
    wow64_ext_glGenSymbolsEXT,
    wow64_ext_glGenTexturesEXT,
    wow64_ext_glGenTransformFeedbacks,
    wow64_ext_glGenTransformFeedbacksNV,
    wow64_ext_glGenVertexArrays,
    wow64_ext_glGenVertexArraysAPPLE,
    wow64_ext_glGenVertexShadersEXT,
    wow64_ext_glGenerateMipmap,
    wow64_ext_glGenerateMipmapEXT,
    wow64_ext_glGenerateMultiTexMipmapEXT,
    wow64_ext_glGenerateTextureMipmap,
    wow64_ext_glGenerateTextureMipmapEXT,
    wow64_ext_glGetActiveAtomicCounterBufferiv,
    wow64_ext_glGetActiveAttrib,
    wow64_ext_glGetActiveAttribARB,
    wow64_ext_glGetActiveSubroutineName,
    wow64_ext_glGetActiveSubroutineUniformName,
    wow64_ext_glGetActiveSubroutineUniformiv,
    wow64_ext_glGetActiveUniform,
    wow64_ext_glGetActiveUniformARB,
    wow64_ext_glGetActiveUniformBlockName,
    wow64_ext_glGetActiveUniformBlockiv,
    wow64_ext_glGetActiveUniformName,
    wow64_ext_glGetActiveUniformsiv,
    wow64_ext_glGetActiveVaryingNV,
    wow64_ext_glGetArrayObjectfvATI,
    wow64_ext_glGetArrayObjectivATI,
    wow64_ext_glGetAttachedObjectsARB,
    wow64_ext_glGetAttachedShaders,
    wow64_ext_glGetAttribLocation,
    wow64_ext_glGetAttribLocationARB,
    wow64_ext_glGetBooleanIndexedvEXT,
    wow64_ext_glGetBooleani_v,
    wow64_ext_glGetBufferParameteri64v,
    wow64_ext_glGetBufferParameteriv,
    wow64_ext_glGetBufferParameterivARB,
    wow64_ext_glGetBufferParameterui64vNV,
    wow64_ext_glGetBufferPointerv,
    wow64_ext_glGetBufferPointervARB,
    wow64_ext_glGetBufferSubData,
    wow64_ext_glGetBufferSubDataARB,
    wow64_ext_glGetClipPlanef,
    wow64_ext_glGetClipPlanefOES,
    wow64_ext_glGetClipPlanex,
    wow64_ext_glGetClipPlanexOES,
    wow64_ext_glGetColorTable,
    wow64_ext_glGetColorTableEXT,
    wow64_ext_glGetColorTableParameterfv,
    wow64_ext_glGetColorTableParameterfvEXT,
    wow64_ext_glGetColorTableParameterfvSGI,
    wow64_ext_glGetColorTableParameteriv,
    wow64_ext_glGetColorTableParameterivEXT,
    wow64_ext_glGetColorTableParameterivSGI,
    wow64_ext_glGetColorTableSGI,
    wow64_ext_glGetCombinerInputParameterfvNV,
    wow64_ext_glGetCombinerInputParameterivNV,
    wow64_ext_glGetCombinerOutputParameterfvNV,
    wow64_ext_glGetCombinerOutputParameterivNV,
    wow64_ext_glGetCombinerStageParameterfvNV,
    wow64_ext_glGetCommandHeaderNV,
    wow64_ext_glGetCompressedMultiTexImageEXT,
    wow64_ext_glGetCompressedTexImage,
    wow64_ext_glGetCompressedTexImageARB,
    wow64_ext_glGetCompressedTextureImage,
    wow64_ext_glGetCompressedTextureImageEXT,
    wow64_ext_glGetCompressedTextureSubImage,
    wow64_ext_glGetConvolutionFilter,
    wow64_ext_glGetConvolutionFilterEXT,
    wow64_ext_glGetConvolutionParameterfv,
    wow64_ext_glGetConvolutionParameterfvEXT,
    wow64_ext_glGetConvolutionParameteriv,
    wow64_ext_glGetConvolutionParameterivEXT,
    wow64_ext_glGetConvolutionParameterxvOES,
    wow64_ext_glGetCoverageModulationTableNV,
    wow64_ext_glGetDebugMessageLog,
    wow64_ext_glGetDebugMessageLogAMD,
    wow64_ext_glGetDebugMessageLogARB,
    wow64_ext_glGetDetailTexFuncSGIS,
    wow64_ext_glGetDoubleIndexedvEXT,
    wow64_ext_glGetDoublei_v,
    wow64_ext_glGetDoublei_vEXT,
    wow64_ext_glGetFenceivNV,
    wow64_ext_glGetFinalCombinerInputParameterfvNV,
    wow64_ext_glGetFinalCombinerInputParameterivNV,
    wow64_ext_glGetFirstPerfQueryIdINTEL,
    wow64_ext_glGetFixedv,
    wow64_ext_glGetFixedvOES,
    wow64_ext_glGetFloatIndexedvEXT,
    wow64_ext_glGetFloati_v,
    wow64_ext_glGetFloati_vEXT,
    wow64_ext_glGetFogFuncSGIS,
    wow64_ext_glGetFragDataIndex,
    wow64_ext_glGetFragDataLocation,
    wow64_ext_glGetFragDataLocationEXT,
    wow64_ext_glGetFragmentLightfvSGIX,
    wow64_ext_glGetFragmentLightivSGIX,
    wow64_ext_glGetFragmentMaterialfvSGIX,
    wow64_ext_glGetFragmentMaterialivSGIX,
    wow64_ext_glGetFragmentShadingRatesEXT,
    wow64_ext_glGetFramebufferAttachmentParameteriv,
    wow64_ext_glGetFramebufferAttachmentParameterivEXT,
    wow64_ext_glGetFramebufferParameterfvAMD,
    wow64_ext_glGetFramebufferParameteriv,
    wow64_ext_glGetFramebufferParameterivEXT,
    wow64_ext_glGetFramebufferParameterivMESA,
    wow64_ext_glGetGraphicsResetStatus,
    wow64_ext_glGetGraphicsResetStatusARB,
    wow64_ext_glGetHandleARB,
    wow64_ext_glGetHistogram,
    wow64_ext_glGetHistogramEXT,
    wow64_ext_glGetHistogramParameterfv,
    wow64_ext_glGetHistogramParameterfvEXT,
    wow64_ext_glGetHistogramParameteriv,
    wow64_ext_glGetHistogramParameterivEXT,
    wow64_ext_glGetHistogramParameterxvOES,
    wow64_ext_glGetImageHandleARB,
    wow64_ext_glGetImageHandleNV,
    wow64_ext_glGetImageTransformParameterfvHP,
    wow64_ext_glGetImageTransformParameterivHP,
    wow64_ext_glGetInfoLogARB,
    wow64_ext_glGetInstrumentsSGIX,
    wow64_ext_glGetInteger64i_v,
    wow64_ext_glGetInteger64v,
    wow64_ext_glGetIntegerIndexedvEXT,
    wow64_ext_glGetIntegeri_v,
    wow64_ext_glGetIntegerui64i_vNV,
    wow64_ext_glGetIntegerui64vNV,
    wow64_ext_glGetInternalformatSampleivNV,
    wow64_ext_glGetInternalformati64v,
    wow64_ext_glGetInternalformativ,
    wow64_ext_glGetInvariantBooleanvEXT,
    wow64_ext_glGetInvariantFloatvEXT,
    wow64_ext_glGetInvariantIntegervEXT,
    wow64_ext_glGetLightxOES,
    wow64_ext_glGetLightxv,
    wow64_ext_glGetListParameterfvSGIX,
    wow64_ext_glGetListParameterivSGIX,
    wow64_ext_glGetLocalConstantBooleanvEXT,
    wow64_ext_glGetLocalConstantFloatvEXT,
    wow64_ext_glGetLocalConstantIntegervEXT,
    wow64_ext_glGetMapAttribParameterfvNV,
    wow64_ext_glGetMapAttribParameterivNV,
    wow64_ext_glGetMapControlPointsNV,
    wow64_ext_glGetMapParameterfvNV,
    wow64_ext_glGetMapParameterivNV,
    wow64_ext_glGetMapxvOES,
    wow64_ext_glGetMaterialxOES,
    wow64_ext_glGetMaterialxv,
    wow64_ext_glGetMemoryObjectDetachedResourcesuivNV,
    wow64_ext_glGetMemoryObjectParameterivEXT,
    wow64_ext_glGetMinmax,
    wow64_ext_glGetMinmaxEXT,
    wow64_ext_glGetMinmaxParameterfv,
    wow64_ext_glGetMinmaxParameterfvEXT,
    wow64_ext_glGetMinmaxParameteriv,
    wow64_ext_glGetMinmaxParameterivEXT,
    wow64_ext_glGetMultiTexEnvfvEXT,
    wow64_ext_glGetMultiTexEnvivEXT,
    wow64_ext_glGetMultiTexGendvEXT,
    wow64_ext_glGetMultiTexGenfvEXT,
    wow64_ext_glGetMultiTexGenivEXT,
    wow64_ext_glGetMultiTexImageEXT,
    wow64_ext_glGetMultiTexLevelParameterfvEXT,
    wow64_ext_glGetMultiTexLevelParameterivEXT,
    wow64_ext_glGetMultiTexParameterIivEXT,
    wow64_ext_glGetMultiTexParameterIuivEXT,
    wow64_ext_glGetMultiTexParameterfvEXT,
    wow64_ext_glGetMultiTexParameterivEXT,
    wow64_ext_glGetMultisamplefv,
    wow64_ext_glGetMultisamplefvNV,
    wow64_ext_glGetNamedBufferParameteri64v,
    wow64_ext_glGetNamedBufferParameteriv,
    wow64_ext_glGetNamedBufferParameterivEXT,
    wow64_ext_glGetNamedBufferParameterui64vNV,
    wow64_ext_glGetNamedBufferPointerv,
    wow64_ext_glGetNamedBufferPointervEXT,
    wow64_ext_glGetNamedBufferSubData,
    wow64_ext_glGetNamedBufferSubDataEXT,
    wow64_ext_glGetNamedFramebufferAttachmentParameteriv,
    wow64_ext_glGetNamedFramebufferAttachmentParameterivEXT,
    wow64_ext_glGetNamedFramebufferParameterfvAMD,
    wow64_ext_glGetNamedFramebufferParameteriv,
    wow64_ext_glGetNamedFramebufferParameterivEXT,
    wow64_ext_glGetNamedProgramLocalParameterIivEXT,
    wow64_ext_glGetNamedProgramLocalParameterIuivEXT,
    wow64_ext_glGetNamedProgramLocalParameterdvEXT,
    wow64_ext_glGetNamedProgramLocalParameterfvEXT,
    wow64_ext_glGetNamedProgramStringEXT,
    wow64_ext_glGetNamedProgramivEXT,
    wow64_ext_glGetNamedRenderbufferParameteriv,
    wow64_ext_glGetNamedRenderbufferParameterivEXT,
    wow64_ext_glGetNamedStringARB,
    wow64_ext_glGetNamedStringivARB,
    wow64_ext_glGetNextPerfQueryIdINTEL,
    wow64_ext_glGetObjectBufferfvATI,
    wow64_ext_glGetObjectBufferivATI,
    wow64_ext_glGetObjectLabel,
    wow64_ext_glGetObjectLabelEXT,
    wow64_ext_glGetObjectParameterfvARB,
    wow64_ext_glGetObjectParameterivAPPLE,
    wow64_ext_glGetObjectParameterivARB,
    wow64_ext_glGetObjectPtrLabel,
    wow64_ext_glGetOcclusionQueryivNV,
    wow64_ext_glGetOcclusionQueryuivNV,
    wow64_ext_glGetPathColorGenfvNV,
    wow64_ext_glGetPathColorGenivNV,
    wow64_ext_glGetPathCommandsNV,
    wow64_ext_glGetPathCoordsNV,
    wow64_ext_glGetPathDashArrayNV,
    wow64_ext_glGetPathLengthNV,
    wow64_ext_glGetPathMetricRangeNV,
    wow64_ext_glGetPathMetricsNV,
    wow64_ext_glGetPathParameterfvNV,
    wow64_ext_glGetPathParameterivNV,
    wow64_ext_glGetPathSpacingNV,
    wow64_ext_glGetPathTexGenfvNV,
    wow64_ext_glGetPathTexGenivNV,
    wow64_ext_glGetPerfCounterInfoINTEL,
    wow64_ext_glGetPerfMonitorCounterDataAMD,
    wow64_ext_glGetPerfMonitorCounterInfoAMD,
    wow64_ext_glGetPerfMonitorCounterStringAMD,
    wow64_ext_glGetPerfMonitorCountersAMD,
    wow64_ext_glGetPerfMonitorGroupStringAMD,
    wow64_ext_glGetPerfMonitorGroupsAMD,
    wow64_ext_glGetPerfQueryDataINTEL,
    wow64_ext_glGetPerfQueryIdByNameINTEL,
    wow64_ext_glGetPerfQueryInfoINTEL,
    wow64_ext_glGetPixelMapxv,
    wow64_ext_glGetPixelTexGenParameterfvSGIS,
    wow64_ext_glGetPixelTexGenParameterivSGIS,
    wow64_ext_glGetPixelTransformParameterfvEXT,
    wow64_ext_glGetPixelTransformParameterivEXT,
    wow64_ext_glGetPointerIndexedvEXT,
    wow64_ext_glGetPointeri_vEXT,
    wow64_ext_glGetPointervEXT,
    wow64_ext_glGetProgramBinary,
    wow64_ext_glGetProgramEnvParameterIivNV,
    wow64_ext_glGetProgramEnvParameterIuivNV,
    wow64_ext_glGetProgramEnvParameterdvARB,
    wow64_ext_glGetProgramEnvParameterfvARB,
    wow64_ext_glGetProgramInfoLog,
    wow64_ext_glGetProgramInterfaceiv,
    wow64_ext_glGetProgramLocalParameterIivNV,
    wow64_ext_glGetProgramLocalParameterIuivNV,
    wow64_ext_glGetProgramLocalParameterdvARB,
    wow64_ext_glGetProgramLocalParameterfvARB,
    wow64_ext_glGetProgramNamedParameterdvNV,
    wow64_ext_glGetProgramNamedParameterfvNV,
    wow64_ext_glGetProgramParameterdvNV,
    wow64_ext_glGetProgramParameterfvNV,
    wow64_ext_glGetProgramPipelineInfoLog,
    wow64_ext_glGetProgramPipelineiv,
    wow64_ext_glGetProgramResourceIndex,
    wow64_ext_glGetProgramResourceLocation,
    wow64_ext_glGetProgramResourceLocationIndex,
    wow64_ext_glGetProgramResourceName,
    wow64_ext_glGetProgramResourcefvNV,
    wow64_ext_glGetProgramResourceiv,
    wow64_ext_glGetProgramStageiv,
    wow64_ext_glGetProgramStringARB,
    wow64_ext_glGetProgramStringNV,
    wow64_ext_glGetProgramSubroutineParameteruivNV,
    wow64_ext_glGetProgramiv,
    wow64_ext_glGetProgramivARB,
    wow64_ext_glGetProgramivNV,
    wow64_ext_glGetQueryBufferObjecti64v,
    wow64_ext_glGetQueryBufferObjectiv,
    wow64_ext_glGetQueryBufferObjectui64v,
    wow64_ext_glGetQueryBufferObjectuiv,
    wow64_ext_glGetQueryIndexediv,
    wow64_ext_glGetQueryObjecti64v,
    wow64_ext_glGetQueryObjecti64vEXT,
    wow64_ext_glGetQueryObjectiv,
    wow64_ext_glGetQueryObjectivARB,
    wow64_ext_glGetQueryObjectui64v,
    wow64_ext_glGetQueryObjectui64vEXT,
    wow64_ext_glGetQueryObjectuiv,
    wow64_ext_glGetQueryObjectuivARB,
    wow64_ext_glGetQueryiv,
    wow64_ext_glGetQueryivARB,
    wow64_ext_glGetRenderbufferParameteriv,
    wow64_ext_glGetRenderbufferParameterivEXT,
    wow64_ext_glGetSamplerParameterIiv,
    wow64_ext_glGetSamplerParameterIuiv,
    wow64_ext_glGetSamplerParameterfv,
    wow64_ext_glGetSamplerParameteriv,
    wow64_ext_glGetSemaphoreParameterivNV,
    wow64_ext_glGetSemaphoreParameterui64vEXT,
    wow64_ext_glGetSeparableFilter,
    wow64_ext_glGetSeparableFilterEXT,
    wow64_ext_glGetShaderInfoLog,
    wow64_ext_glGetShaderPrecisionFormat,
    wow64_ext_glGetShaderSource,
    wow64_ext_glGetShaderSourceARB,
    wow64_ext_glGetShaderiv,
    wow64_ext_glGetShadingRateImagePaletteNV,
    wow64_ext_glGetShadingRateSampleLocationivNV,
    wow64_ext_glGetSharpenTexFuncSGIS,
    wow64_ext_glGetStageIndexNV,
    wow64_ext_glGetStringi,
    wow64_ext_glGetSubroutineIndex,
    wow64_ext_glGetSubroutineUniformLocation,
    wow64_ext_glGetSynciv,
    wow64_ext_glGetTexBumpParameterfvATI,
    wow64_ext_glGetTexBumpParameterivATI,
    wow64_ext_glGetTexEnvxv,
    wow64_ext_glGetTexEnvxvOES,
    wow64_ext_glGetTexFilterFuncSGIS,
    wow64_ext_glGetTexGenxvOES,
    wow64_ext_glGetTexLevelParameterxvOES,
    wow64_ext_glGetTexParameterIiv,
    wow64_ext_glGetTexParameterIivEXT,
    wow64_ext_glGetTexParameterIuiv,
    wow64_ext_glGetTexParameterIuivEXT,
    wow64_ext_glGetTexParameterPointervAPPLE,
    wow64_ext_glGetTexParameterxv,
    wow64_ext_glGetTexParameterxvOES,
    wow64_ext_glGetTextureHandleARB,
    wow64_ext_glGetTextureHandleNV,
    wow64_ext_glGetTextureImage,
    wow64_ext_glGetTextureImageEXT,
    wow64_ext_glGetTextureLevelParameterfv,
    wow64_ext_glGetTextureLevelParameterfvEXT,
    wow64_ext_glGetTextureLevelParameteriv,
    wow64_ext_glGetTextureLevelParameterivEXT,
    wow64_ext_glGetTextureParameterIiv,
    wow64_ext_glGetTextureParameterIivEXT,
    wow64_ext_glGetTextureParameterIuiv,
    wow64_ext_glGetTextureParameterIuivEXT,
    wow64_ext_glGetTextureParameterfv,
    wow64_ext_glGetTextureParameterfvEXT,
    wow64_ext_glGetTextureParameteriv,
    wow64_ext_glGetTextureParameterivEXT,
    wow64_ext_glGetTextureSamplerHandleARB,
    wow64_ext_glGetTextureSamplerHandleNV,
    wow64_ext_glGetTextureSubImage,
    wow64_ext_glGetTrackMatrixivNV,
    wow64_ext_glGetTransformFeedbackVarying,
    wow64_ext_glGetTransformFeedbackVaryingEXT,
    wow64_ext_glGetTransformFeedbackVaryingNV,
    wow64_ext_glGetTransformFeedbacki64_v,
    wow64_ext_glGetTransformFeedbacki_v,
    wow64_ext_glGetTransformFeedbackiv,
    wow64_ext_glGetUniformBlockIndex,
    wow64_ext_glGetUniformBufferSizeEXT,
    wow64_ext_glGetUniformIndices,
    wow64_ext_glGetUniformLocation,
    wow64_ext_glGetUniformLocationARB,
    wow64_ext_glGetUniformOffsetEXT,
    wow64_ext_glGetUniformSubroutineuiv,
    wow64_ext_glGetUniformdv,
    wow64_ext_glGetUniformfv,
    wow64_ext_glGetUniformfvARB,
    wow64_ext_glGetUniformi64vARB,
    wow64_ext_glGetUniformi64vNV,
    wow64_ext_glGetUniformiv,
    wow64_ext_glGetUniformivARB,
    wow64_ext_glGetUniformui64vARB,
    wow64_ext_glGetUniformui64vNV,
    wow64_ext_glGetUniformuiv,
    wow64_ext_glGetUniformuivEXT,
    wow64_ext_glGetUnsignedBytei_vEXT,
    wow64_ext_glGetUnsignedBytevEXT,
    wow64_ext_glGetVariantArrayObjectfvATI,
    wow64_ext_glGetVariantArrayObjectivATI,
    wow64_ext_glGetVariantBooleanvEXT,
    wow64_ext_glGetVariantFloatvEXT,
    wow64_ext_glGetVariantIntegervEXT,
    wow64_ext_glGetVariantPointervEXT,
    wow64_ext_glGetVaryingLocationNV,
    wow64_ext_glGetVertexArrayIndexed64iv,
    wow64_ext_glGetVertexArrayIndexediv,
    wow64_ext_glGetVertexArrayIntegeri_vEXT,
    wow64_ext_glGetVertexArrayIntegervEXT,
    wow64_ext_glGetVertexArrayPointeri_vEXT,
    wow64_ext_glGetVertexArrayPointervEXT,
    wow64_ext_glGetVertexArrayiv,
    wow64_ext_glGetVertexAttribArrayObjectfvATI,
    wow64_ext_glGetVertexAttribArrayObjectivATI,
    wow64_ext_glGetVertexAttribIiv,
    wow64_ext_glGetVertexAttribIivEXT,
    wow64_ext_glGetVertexAttribIuiv,
    wow64_ext_glGetVertexAttribIuivEXT,
    wow64_ext_glGetVertexAttribLdv,
    wow64_ext_glGetVertexAttribLdvEXT,
    wow64_ext_glGetVertexAttribLi64vNV,
    wow64_ext_glGetVertexAttribLui64vARB,
    wow64_ext_glGetVertexAttribLui64vNV,
    wow64_ext_glGetVertexAttribPointerv,
    wow64_ext_glGetVertexAttribPointervARB,
    wow64_ext_glGetVertexAttribPointervNV,
    wow64_ext_glGetVertexAttribdv,
    wow64_ext_glGetVertexAttribdvARB,
    wow64_ext_glGetVertexAttribdvNV,
    wow64_ext_glGetVertexAttribfv,
    wow64_ext_glGetVertexAttribfvARB,
    wow64_ext_glGetVertexAttribfvNV,
    wow64_ext_glGetVertexAttribiv,
    wow64_ext_glGetVertexAttribivARB,
    wow64_ext_glGetVertexAttribivNV,
    wow64_ext_glGetVideoCaptureStreamdvNV,
    wow64_ext_glGetVideoCaptureStreamfvNV,
    wow64_ext_glGetVideoCaptureStreamivNV,
    wow64_ext_glGetVideoCaptureivNV,
    wow64_ext_glGetVideoi64vNV,
    wow64_ext_glGetVideoivNV,
    wow64_ext_glGetVideoui64vNV,
    wow64_ext_glGetVideouivNV,
    wow64_ext_glGetVkProcAddrNV,
    wow64_ext_glGetnColorTable,
    wow64_ext_glGetnColorTableARB,
    wow64_ext_glGetnCompressedTexImage,
    wow64_ext_glGetnCompressedTexImageARB,
    wow64_ext_glGetnConvolutionFilter,
    wow64_ext_glGetnConvolutionFilterARB,
    wow64_ext_glGetnHistogram,
    wow64_ext_glGetnHistogramARB,
    wow64_ext_glGetnMapdv,
    wow64_ext_glGetnMapdvARB,
    wow64_ext_glGetnMapfv,
    wow64_ext_glGetnMapfvARB,
    wow64_ext_glGetnMapiv,
    wow64_ext_glGetnMapivARB,
    wow64_ext_glGetnMinmax,
    wow64_ext_glGetnMinmaxARB,
    wow64_ext_glGetnPixelMapfv,
    wow64_ext_glGetnPixelMapfvARB,
    wow64_ext_glGetnPixelMapuiv,
    wow64_ext_glGetnPixelMapuivARB,
    wow64_ext_glGetnPixelMapusv,
    wow64_ext_glGetnPixelMapusvARB,
    wow64_ext_glGetnPolygonStipple,
    wow64_ext_glGetnPolygonStippleARB,
    wow64_ext_glGetnSeparableFilter,
    wow64_ext_glGetnSeparableFilterARB,
    wow64_ext_glGetnTexImage,
    wow64_ext_glGetnTexImageARB,
    wow64_ext_glGetnUniformdv,
    wow64_ext_glGetnUniformdvARB,
    wow64_ext_glGetnUniformfv,
    wow64_ext_glGetnUniformfvARB,
    wow64_ext_glGetnUniformi64vARB,
    wow64_ext_glGetnUniformiv,
    wow64_ext_glGetnUniformivARB,
    wow64_ext_glGetnUniformui64vARB,
    wow64_ext_glGetnUniformuiv,
    wow64_ext_glGetnUniformuivARB,
    wow64_ext_glGlobalAlphaFactorbSUN,
    wow64_ext_glGlobalAlphaFactordSUN,
    wow64_ext_glGlobalAlphaFactorfSUN,
    wow64_ext_glGlobalAlphaFactoriSUN,
    wow64_ext_glGlobalAlphaFactorsSUN,
    wow64_ext_glGlobalAlphaFactorubSUN,
    wow64_ext_glGlobalAlphaFactoruiSUN,
    wow64_ext_glGlobalAlphaFactorusSUN,
    wow64_ext_glHintPGI,
    wow64_ext_glHistogram,
    wow64_ext_glHistogramEXT,
    wow64_ext_glIglooInterfaceSGIX,
    wow64_ext_glImageTransformParameterfHP,
    wow64_ext_glImageTransformParameterfvHP,
    wow64_ext_glImageTransformParameteriHP,
    wow64_ext_glImageTransformParameterivHP,
    wow64_ext_glImportMemoryWin32HandleEXT,
    wow64_ext_glImportMemoryWin32NameEXT,
    wow64_ext_glImportSemaphoreWin32HandleEXT,
    wow64_ext_glImportSemaphoreWin32NameEXT,
    wow64_ext_glImportSyncEXT,
    wow64_ext_glIndexFormatNV,
    wow64_ext_glIndexFuncEXT,
    wow64_ext_glIndexMaterialEXT,
    wow64_ext_glIndexPointerEXT,
    wow64_ext_glIndexPointerListIBM,
    wow64_ext_glIndexxOES,
    wow64_ext_glIndexxvOES,
    wow64_ext_glInsertComponentEXT,
    wow64_ext_glInsertEventMarkerEXT,
    wow64_ext_glInstrumentsBufferSGIX,
    wow64_ext_glInterpolatePathsNV,
    wow64_ext_glInvalidateBufferData,
    wow64_ext_glInvalidateBufferSubData,
    wow64_ext_glInvalidateFramebuffer,
    wow64_ext_glInvalidateNamedFramebufferData,
    wow64_ext_glInvalidateNamedFramebufferSubData,
    wow64_ext_glInvalidateSubFramebuffer,
    wow64_ext_glInvalidateTexImage,
    wow64_ext_glInvalidateTexSubImage,
    wow64_ext_glIsAsyncMarkerSGIX,
    wow64_ext_glIsBuffer,
    wow64_ext_glIsBufferARB,
    wow64_ext_glIsBufferResidentNV,
    wow64_ext_glIsCommandListNV,
    wow64_ext_glIsEnabledIndexedEXT,
    wow64_ext_glIsEnabledi,
    wow64_ext_glIsFenceAPPLE,
    wow64_ext_glIsFenceNV,
    wow64_ext_glIsFramebuffer,
    wow64_ext_glIsFramebufferEXT,
    wow64_ext_glIsImageHandleResidentARB,
    wow64_ext_glIsImageHandleResidentNV,
    wow64_ext_glIsMemoryObjectEXT,
    wow64_ext_glIsNameAMD,
    wow64_ext_glIsNamedBufferResidentNV,
    wow64_ext_glIsNamedStringARB,
    wow64_ext_glIsObjectBufferATI,
    wow64_ext_glIsOcclusionQueryNV,
    wow64_ext_glIsPathNV,
    wow64_ext_glIsPointInFillPathNV,
    wow64_ext_glIsPointInStrokePathNV,
    wow64_ext_glIsProgram,
    wow64_ext_glIsProgramARB,
    wow64_ext_glIsProgramNV,
    wow64_ext_glIsProgramPipeline,
    wow64_ext_glIsQuery,
    wow64_ext_glIsQueryARB,
    wow64_ext_glIsRenderbuffer,
    wow64_ext_glIsRenderbufferEXT,
    wow64_ext_glIsSampler,
    wow64_ext_glIsSemaphoreEXT,
    wow64_ext_glIsShader,
    wow64_ext_glIsStateNV,
    wow64_ext_glIsSync,
    wow64_ext_glIsTextureEXT,
    wow64_ext_glIsTextureHandleResidentARB,
    wow64_ext_glIsTextureHandleResidentNV,
    wow64_ext_glIsTransformFeedback,
    wow64_ext_glIsTransformFeedbackNV,
    wow64_ext_glIsVariantEnabledEXT,
    wow64_ext_glIsVertexArray,
    wow64_ext_glIsVertexArrayAPPLE,
    wow64_ext_glIsVertexAttribEnabledAPPLE,
    wow64_ext_glLGPUCopyImageSubDataNVX,
    wow64_ext_glLGPUInterlockNVX,
    wow64_ext_glLGPUNamedBufferSubDataNVX,
    wow64_ext_glLabelObjectEXT,
    wow64_ext_glLightEnviSGIX,
    wow64_ext_glLightModelx,
    wow64_ext_glLightModelxOES,
    wow64_ext_glLightModelxv,
    wow64_ext_glLightModelxvOES,
    wow64_ext_glLightx,
    wow64_ext_glLightxOES,
    wow64_ext_glLightxv,
    wow64_ext_glLightxvOES,
    wow64_ext_glLineWidthx,
    wow64_ext_glLineWidthxOES,
    wow64_ext_glLinkProgram,
    wow64_ext_glLinkProgramARB,
    wow64_ext_glListDrawCommandsStatesClientNV,
    wow64_ext_glListParameterfSGIX,
    wow64_ext_glListParameterfvSGIX,
    wow64_ext_glListParameteriSGIX,
    wow64_ext_glListParameterivSGIX,
    wow64_ext_glLoadIdentityDeformationMapSGIX,
    wow64_ext_glLoadMatrixx,
    wow64_ext_glLoadMatrixxOES,
    wow64_ext_glLoadProgramNV,
    wow64_ext_glLoadTransposeMatrixd,
    wow64_ext_glLoadTransposeMatrixdARB,
    wow64_ext_glLoadTransposeMatrixf,
    wow64_ext_glLoadTransposeMatrixfARB,
    wow64_ext_glLoadTransposeMatrixxOES,
    wow64_ext_glLockArraysEXT,
    wow64_ext_glMTexCoord2fSGIS,
    wow64_ext_glMTexCoord2fvSGIS,
    wow64_ext_glMakeBufferNonResidentNV,
    wow64_ext_glMakeBufferResidentNV,
    wow64_ext_glMakeImageHandleNonResidentARB,
    wow64_ext_glMakeImageHandleNonResidentNV,
    wow64_ext_glMakeImageHandleResidentARB,
    wow64_ext_glMakeImageHandleResidentNV,
    wow64_ext_glMakeNamedBufferNonResidentNV,
    wow64_ext_glMakeNamedBufferResidentNV,
    wow64_ext_glMakeTextureHandleNonResidentARB,
    wow64_ext_glMakeTextureHandleNonResidentNV,
    wow64_ext_glMakeTextureHandleResidentARB,
    wow64_ext_glMakeTextureHandleResidentNV,
    wow64_ext_glMap1xOES,
    wow64_ext_glMap2xOES,
    wow64_ext_glMapBuffer,
    wow64_ext_glMapBufferARB,
    wow64_ext_glMapBufferRange,
    wow64_ext_glMapControlPointsNV,
    wow64_ext_glMapGrid1xOES,
    wow64_ext_glMapGrid2xOES,
    wow64_ext_glMapNamedBuffer,
    wow64_ext_glMapNamedBufferEXT,
    wow64_ext_glMapNamedBufferRange,
    wow64_ext_glMapNamedBufferRangeEXT,
    wow64_ext_glMapObjectBufferATI,
    wow64_ext_glMapParameterfvNV,
    wow64_ext_glMapParameterivNV,
    wow64_ext_glMapTexture2DINTEL,
    wow64_ext_glMapVertexAttrib1dAPPLE,
    wow64_ext_glMapVertexAttrib1fAPPLE,
    wow64_ext_glMapVertexAttrib2dAPPLE,
    wow64_ext_glMapVertexAttrib2fAPPLE,
    wow64_ext_glMaterialx,
    wow64_ext_glMaterialxOES,
    wow64_ext_glMaterialxv,
    wow64_ext_glMaterialxvOES,
    wow64_ext_glMatrixFrustumEXT,
    wow64_ext_glMatrixIndexPointerARB,
    wow64_ext_glMatrixIndexubvARB,
    wow64_ext_glMatrixIndexuivARB,
    wow64_ext_glMatrixIndexusvARB,
    wow64_ext_glMatrixLoad3x2fNV,
    wow64_ext_glMatrixLoad3x3fNV,
    wow64_ext_glMatrixLoadIdentityEXT,
    wow64_ext_glMatrixLoadTranspose3x3fNV,
    wow64_ext_glMatrixLoadTransposedEXT,
    wow64_ext_glMatrixLoadTransposefEXT,
    wow64_ext_glMatrixLoaddEXT,
    wow64_ext_glMatrixLoadfEXT,
    wow64_ext_glMatrixMult3x2fNV,
    wow64_ext_glMatrixMult3x3fNV,
    wow64_ext_glMatrixMultTranspose3x3fNV,
    wow64_ext_glMatrixMultTransposedEXT,
    wow64_ext_glMatrixMultTransposefEXT,
    wow64_ext_glMatrixMultdEXT,
    wow64_ext_glMatrixMultfEXT,
    wow64_ext_glMatrixOrthoEXT,
    wow64_ext_glMatrixPopEXT,
    wow64_ext_glMatrixPushEXT,
    wow64_ext_glMatrixRotatedEXT,
    wow64_ext_glMatrixRotatefEXT,
    wow64_ext_glMatrixScaledEXT,
    wow64_ext_glMatrixScalefEXT,
    wow64_ext_glMatrixTranslatedEXT,
    wow64_ext_glMatrixTranslatefEXT,
    wow64_ext_glMaxShaderCompilerThreadsARB,
    wow64_ext_glMaxShaderCompilerThreadsKHR,
    wow64_ext_glMemoryBarrier,
    wow64_ext_glMemoryBarrierByRegion,
    wow64_ext_glMemoryBarrierEXT,
    wow64_ext_glMemoryObjectParameterivEXT,
    wow64_ext_glMinSampleShading,
    wow64_ext_glMinSampleShadingARB,
    wow64_ext_glMinmax,
    wow64_ext_glMinmaxEXT,
    wow64_ext_glMultMatrixx,
    wow64_ext_glMultMatrixxOES,
    wow64_ext_glMultTransposeMatrixd,
    wow64_ext_glMultTransposeMatrixdARB,
    wow64_ext_glMultTransposeMatrixf,
    wow64_ext_glMultTransposeMatrixfARB,
    wow64_ext_glMultTransposeMatrixxOES,
    wow64_ext_glMultiDrawArrays,
    wow64_ext_glMultiDrawArraysEXT,
    wow64_ext_glMultiDrawArraysIndirect,
    wow64_ext_glMultiDrawArraysIndirectAMD,
    wow64_ext_glMultiDrawArraysIndirectBindlessCountNV,
    wow64_ext_glMultiDrawArraysIndirectBindlessNV,
    wow64_ext_glMultiDrawArraysIndirectCount,
    wow64_ext_glMultiDrawArraysIndirectCountARB,
    wow64_ext_glMultiDrawElementArrayAPPLE,
    wow64_ext_glMultiDrawElements,
    wow64_ext_glMultiDrawElementsBaseVertex,
    wow64_ext_glMultiDrawElementsEXT,
    wow64_ext_glMultiDrawElementsIndirect,
    wow64_ext_glMultiDrawElementsIndirectAMD,
    wow64_ext_glMultiDrawElementsIndirectBindlessCountNV,
    wow64_ext_glMultiDrawElementsIndirectBindlessNV,
    wow64_ext_glMultiDrawElementsIndirectCount,
    wow64_ext_glMultiDrawElementsIndirectCountARB,
    wow64_ext_glMultiDrawMeshTasksIndirectCountEXT,
    wow64_ext_glMultiDrawMeshTasksIndirectCountNV,
    wow64_ext_glMultiDrawMeshTasksIndirectEXT,
    wow64_ext_glMultiDrawMeshTasksIndirectNV,
    wow64_ext_glMultiDrawRangeElementArrayAPPLE,
    wow64_ext_glMultiModeDrawArraysIBM,
    wow64_ext_glMultiModeDrawElementsIBM,
    wow64_ext_glMultiTexBufferEXT,
    wow64_ext_glMultiTexCoord1bOES,
    wow64_ext_glMultiTexCoord1bvOES,
    wow64_ext_glMultiTexCoord1d,
    wow64_ext_glMultiTexCoord1dARB,
    wow64_ext_glMultiTexCoord1dSGIS,
    wow64_ext_glMultiTexCoord1dv,
    wow64_ext_glMultiTexCoord1dvARB,
    wow64_ext_glMultiTexCoord1dvSGIS,
    wow64_ext_glMultiTexCoord1f,
    wow64_ext_glMultiTexCoord1fARB,
    wow64_ext_glMultiTexCoord1fSGIS,
    wow64_ext_glMultiTexCoord1fv,
    wow64_ext_glMultiTexCoord1fvARB,
    wow64_ext_glMultiTexCoord1fvSGIS,
    wow64_ext_glMultiTexCoord1hNV,
    wow64_ext_glMultiTexCoord1hvNV,
    wow64_ext_glMultiTexCoord1i,
    wow64_ext_glMultiTexCoord1iARB,
    wow64_ext_glMultiTexCoord1iSGIS,
    wow64_ext_glMultiTexCoord1iv,
    wow64_ext_glMultiTexCoord1ivARB,
    wow64_ext_glMultiTexCoord1ivSGIS,
    wow64_ext_glMultiTexCoord1s,
    wow64_ext_glMultiTexCoord1sARB,
    wow64_ext_glMultiTexCoord1sSGIS,
    wow64_ext_glMultiTexCoord1sv,
    wow64_ext_glMultiTexCoord1svARB,
    wow64_ext_glMultiTexCoord1svSGIS,
    wow64_ext_glMultiTexCoord1xOES,
    wow64_ext_glMultiTexCoord1xvOES,
    wow64_ext_glMultiTexCoord2bOES,
    wow64_ext_glMultiTexCoord2bvOES,
    wow64_ext_glMultiTexCoord2d,
    wow64_ext_glMultiTexCoord2dARB,
    wow64_ext_glMultiTexCoord2dSGIS,
    wow64_ext_glMultiTexCoord2dv,
    wow64_ext_glMultiTexCoord2dvARB,
    wow64_ext_glMultiTexCoord2dvSGIS,
    wow64_ext_glMultiTexCoord2f,
    wow64_ext_glMultiTexCoord2fARB,
    wow64_ext_glMultiTexCoord2fSGIS,
    wow64_ext_glMultiTexCoord2fv,
    wow64_ext_glMultiTexCoord2fvARB,
    wow64_ext_glMultiTexCoord2fvSGIS,
    wow64_ext_glMultiTexCoord2hNV,
    wow64_ext_glMultiTexCoord2hvNV,
    wow64_ext_glMultiTexCoord2i,
    wow64_ext_glMultiTexCoord2iARB,
    wow64_ext_glMultiTexCoord2iSGIS,
    wow64_ext_glMultiTexCoord2iv,
    wow64_ext_glMultiTexCoord2ivARB,
    wow64_ext_glMultiTexCoord2ivSGIS,
    wow64_ext_glMultiTexCoord2s,
    wow64_ext_glMultiTexCoord2sARB,
    wow64_ext_glMultiTexCoord2sSGIS,
    wow64_ext_glMultiTexCoord2sv,
    wow64_ext_glMultiTexCoord2svARB,
    wow64_ext_glMultiTexCoord2svSGIS,
    wow64_ext_glMultiTexCoord2xOES,
    wow64_ext_glMultiTexCoord2xvOES,
    wow64_ext_glMultiTexCoord3bOES,
    wow64_ext_glMultiTexCoord3bvOES,
    wow64_ext_glMultiTexCoord3d,
    wow64_ext_glMultiTexCoord3dARB,
    wow64_ext_glMultiTexCoord3dSGIS,
    wow64_ext_glMultiTexCoord3dv,
    wow64_ext_glMultiTexCoord3dvARB,
    wow64_ext_glMultiTexCoord3dvSGIS,
    wow64_ext_glMultiTexCoord3f,
    wow64_ext_glMultiTexCoord3fARB,
    wow64_ext_glMultiTexCoord3fSGIS,
    wow64_ext_glMultiTexCoord3fv,
    wow64_ext_glMultiTexCoord3fvARB,
    wow64_ext_glMultiTexCoord3fvSGIS,
    wow64_ext_glMultiTexCoord3hNV,
    wow64_ext_glMultiTexCoord3hvNV,
    wow64_ext_glMultiTexCoord3i,
    wow64_ext_glMultiTexCoord3iARB,
    wow64_ext_glMultiTexCoord3iSGIS,
    wow64_ext_glMultiTexCoord3iv,
    wow64_ext_glMultiTexCoord3ivARB,
    wow64_ext_glMultiTexCoord3ivSGIS,
    wow64_ext_glMultiTexCoord3s,
    wow64_ext_glMultiTexCoord3sARB,
    wow64_ext_glMultiTexCoord3sSGIS,
    wow64_ext_glMultiTexCoord3sv,
    wow64_ext_glMultiTexCoord3svARB,
    wow64_ext_glMultiTexCoord3svSGIS,
    wow64_ext_glMultiTexCoord3xOES,
    wow64_ext_glMultiTexCoord3xvOES,
    wow64_ext_glMultiTexCoord4bOES,
    wow64_ext_glMultiTexCoord4bvOES,
    wow64_ext_glMultiTexCoord4d,
    wow64_ext_glMultiTexCoord4dARB,
    wow64_ext_glMultiTexCoord4dSGIS,
    wow64_ext_glMultiTexCoord4dv,
    wow64_ext_glMultiTexCoord4dvARB,
    wow64_ext_glMultiTexCoord4dvSGIS,
    wow64_ext_glMultiTexCoord4f,
    wow64_ext_glMultiTexCoord4fARB,
    wow64_ext_glMultiTexCoord4fSGIS,
    wow64_ext_glMultiTexCoord4fv,
    wow64_ext_glMultiTexCoord4fvARB,
    wow64_ext_glMultiTexCoord4fvSGIS,
    wow64_ext_glMultiTexCoord4hNV,
    wow64_ext_glMultiTexCoord4hvNV,
    wow64_ext_glMultiTexCoord4i,
    wow64_ext_glMultiTexCoord4iARB,
    wow64_ext_glMultiTexCoord4iSGIS,
    wow64_ext_glMultiTexCoord4iv,
    wow64_ext_glMultiTexCoord4ivARB,
    wow64_ext_glMultiTexCoord4ivSGIS,
    wow64_ext_glMultiTexCoord4s,
    wow64_ext_glMultiTexCoord4sARB,
    wow64_ext_glMultiTexCoord4sSGIS,
    wow64_ext_glMultiTexCoord4sv,
    wow64_ext_glMultiTexCoord4svARB,
    wow64_ext_glMultiTexCoord4svSGIS,
    wow64_ext_glMultiTexCoord4x,
    wow64_ext_glMultiTexCoord4xOES,
    wow64_ext_glMultiTexCoord4xvOES,
    wow64_ext_glMultiTexCoordP1ui,
    wow64_ext_glMultiTexCoordP1uiv,
    wow64_ext_glMultiTexCoordP2ui,
    wow64_ext_glMultiTexCoordP2uiv,
    wow64_ext_glMultiTexCoordP3ui,
    wow64_ext_glMultiTexCoordP3uiv,
    wow64_ext_glMultiTexCoordP4ui,
    wow64_ext_glMultiTexCoordP4uiv,
    wow64_ext_glMultiTexCoordPointerEXT,
    wow64_ext_glMultiTexCoordPointerSGIS,
    wow64_ext_glMultiTexEnvfEXT,
    wow64_ext_glMultiTexEnvfvEXT,
    wow64_ext_glMultiTexEnviEXT,
    wow64_ext_glMultiTexEnvivEXT,
    wow64_ext_glMultiTexGendEXT,
    wow64_ext_glMultiTexGendvEXT,
    wow64_ext_glMultiTexGenfEXT,
    wow64_ext_glMultiTexGenfvEXT,
    wow64_ext_glMultiTexGeniEXT,
    wow64_ext_glMultiTexGenivEXT,
    wow64_ext_glMultiTexImage1DEXT,
    wow64_ext_glMultiTexImage2DEXT,
    wow64_ext_glMultiTexImage3DEXT,
    wow64_ext_glMultiTexParameterIivEXT,
    wow64_ext_glMultiTexParameterIuivEXT,
    wow64_ext_glMultiTexParameterfEXT,
    wow64_ext_glMultiTexParameterfvEXT,
    wow64_ext_glMultiTexParameteriEXT,
    wow64_ext_glMultiTexParameterivEXT,
    wow64_ext_glMultiTexRenderbufferEXT,
    wow64_ext_glMultiTexSubImage1DEXT,
    wow64_ext_glMultiTexSubImage2DEXT,
    wow64_ext_glMultiTexSubImage3DEXT,
    wow64_ext_glMulticastBarrierNV,
    wow64_ext_glMulticastBlitFramebufferNV,
    wow64_ext_glMulticastBufferSubDataNV,
    wow64_ext_glMulticastCopyBufferSubDataNV,
    wow64_ext_glMulticastCopyImageSubDataNV,
    wow64_ext_glMulticastFramebufferSampleLocationsfvNV,
    wow64_ext_glMulticastGetQueryObjecti64vNV,
    wow64_ext_glMulticastGetQueryObjectivNV,
    wow64_ext_glMulticastGetQueryObjectui64vNV,
    wow64_ext_glMulticastGetQueryObjectuivNV,
    wow64_ext_glMulticastScissorArrayvNVX,
    wow64_ext_glMulticastViewportArrayvNVX,
    wow64_ext_glMulticastViewportPositionWScaleNVX,
    wow64_ext_glMulticastWaitSyncNV,
    wow64_ext_glNamedBufferAttachMemoryNV,
    wow64_ext_glNamedBufferData,
    wow64_ext_glNamedBufferDataEXT,
    wow64_ext_glNamedBufferPageCommitmentARB,
    wow64_ext_glNamedBufferPageCommitmentEXT,
    wow64_ext_glNamedBufferPageCommitmentMemNV,
    wow64_ext_glNamedBufferStorage,
    wow64_ext_glNamedBufferStorageEXT,
    wow64_ext_glNamedBufferStorageMemEXT,
    wow64_ext_glNamedBufferSubData,
    wow64_ext_glNamedBufferSubDataEXT,
    wow64_ext_glNamedCopyBufferSubDataEXT,
    wow64_ext_glNamedFramebufferDrawBuffer,
    wow64_ext_glNamedFramebufferDrawBuffers,
    wow64_ext_glNamedFramebufferParameteri,
    wow64_ext_glNamedFramebufferParameteriEXT,
    wow64_ext_glNamedFramebufferReadBuffer,
    wow64_ext_glNamedFramebufferRenderbuffer,
    wow64_ext_glNamedFramebufferRenderbufferEXT,
    wow64_ext_glNamedFramebufferSampleLocationsfvARB,
    wow64_ext_glNamedFramebufferSampleLocationsfvNV,
    wow64_ext_glNamedFramebufferSamplePositionsfvAMD,
    wow64_ext_glNamedFramebufferTexture,
    wow64_ext_glNamedFramebufferTexture1DEXT,
    wow64_ext_glNamedFramebufferTexture2DEXT,
    wow64_ext_glNamedFramebufferTexture3DEXT,
    wow64_ext_glNamedFramebufferTextureEXT,
    wow64_ext_glNamedFramebufferTextureFaceEXT,
    wow64_ext_glNamedFramebufferTextureLayer,
    wow64_ext_glNamedFramebufferTextureLayerEXT,
    wow64_ext_glNamedFramebufferTextureMultiviewOVR,
    wow64_ext_glNamedProgramLocalParameter4dEXT,
    wow64_ext_glNamedProgramLocalParameter4dvEXT,
    wow64_ext_glNamedProgramLocalParameter4fEXT,
    wow64_ext_glNamedProgramLocalParameter4fvEXT,
    wow64_ext_glNamedProgramLocalParameterI4iEXT,
    wow64_ext_glNamedProgramLocalParameterI4ivEXT,
    wow64_ext_glNamedProgramLocalParameterI4uiEXT,
    wow64_ext_glNamedProgramLocalParameterI4uivEXT,
    wow64_ext_glNamedProgramLocalParameters4fvEXT,
    wow64_ext_glNamedProgramLocalParametersI4ivEXT,
    wow64_ext_glNamedProgramLocalParametersI4uivEXT,
    wow64_ext_glNamedProgramStringEXT,
    wow64_ext_glNamedRenderbufferStorage,
    wow64_ext_glNamedRenderbufferStorageEXT,
    wow64_ext_glNamedRenderbufferStorageMultisample,
    wow64_ext_glNamedRenderbufferStorageMultisampleAdvancedAMD,
    wow64_ext_glNamedRenderbufferStorageMultisampleCoverageEXT,
    wow64_ext_glNamedRenderbufferStorageMultisampleEXT,
    wow64_ext_glNamedStringARB,
    wow64_ext_glNewBufferRegion,
    wow64_ext_glNewObjectBufferATI,
    wow64_ext_glNormal3fVertex3fSUN,
    wow64_ext_glNormal3fVertex3fvSUN,
    wow64_ext_glNormal3hNV,
    wow64_ext_glNormal3hvNV,
    wow64_ext_glNormal3x,
    wow64_ext_glNormal3xOES,
    wow64_ext_glNormal3xvOES,
    wow64_ext_glNormalFormatNV,
    wow64_ext_glNormalP3ui,
    wow64_ext_glNormalP3uiv,
    wow64_ext_glNormalPointerEXT,
    wow64_ext_glNormalPointerListIBM,
    wow64_ext_glNormalPointervINTEL,
    wow64_ext_glNormalStream3bATI,
    wow64_ext_glNormalStream3bvATI,
    wow64_ext_glNormalStream3dATI,
    wow64_ext_glNormalStream3dvATI,
    wow64_ext_glNormalStream3fATI,
    wow64_ext_glNormalStream3fvATI,
    wow64_ext_glNormalStream3iATI,
    wow64_ext_glNormalStream3ivATI,
    wow64_ext_glNormalStream3sATI,
    wow64_ext_glNormalStream3svATI,
    wow64_ext_glObjectLabel,
    wow64_ext_glObjectPtrLabel,
    wow64_ext_glObjectPurgeableAPPLE,
    wow64_ext_glObjectUnpurgeableAPPLE,
    wow64_ext_glOrthof,
    wow64_ext_glOrthofOES,
    wow64_ext_glOrthox,
    wow64_ext_glOrthoxOES,
    wow64_ext_glPNTrianglesfATI,
    wow64_ext_glPNTrianglesiATI,
    wow64_ext_glPassTexCoordATI,
    wow64_ext_glPassThroughxOES,
    wow64_ext_glPatchParameterfv,
    wow64_ext_glPatchParameteri,
    wow64_ext_glPathColorGenNV,
    wow64_ext_glPathCommandsNV,
    wow64_ext_glPathCoordsNV,
    wow64_ext_glPathCoverDepthFuncNV,
    wow64_ext_glPathDashArrayNV,
    wow64_ext_glPathFogGenNV,
    wow64_ext_glPathGlyphIndexArrayNV,
    wow64_ext_glPathGlyphIndexRangeNV,
    wow64_ext_glPathGlyphRangeNV,
    wow64_ext_glPathGlyphsNV,
    wow64_ext_glPathMemoryGlyphIndexArrayNV,
    wow64_ext_glPathParameterfNV,
    wow64_ext_glPathParameterfvNV,
    wow64_ext_glPathParameteriNV,
    wow64_ext_glPathParameterivNV,
    wow64_ext_glPathStencilDepthOffsetNV,
    wow64_ext_glPathStencilFuncNV,
    wow64_ext_glPathStringNV,
    wow64_ext_glPathSubCommandsNV,
    wow64_ext_glPathSubCoordsNV,
    wow64_ext_glPathTexGenNV,
    wow64_ext_glPauseTransformFeedback,
    wow64_ext_glPauseTransformFeedbackNV,
    wow64_ext_glPixelDataRangeNV,
    wow64_ext_glPixelMapx,
    wow64_ext_glPixelStorex,
    wow64_ext_glPixelTexGenParameterfSGIS,
    wow64_ext_glPixelTexGenParameterfvSGIS,
    wow64_ext_glPixelTexGenParameteriSGIS,
    wow64_ext_glPixelTexGenParameterivSGIS,
    wow64_ext_glPixelTexGenSGIX,
    wow64_ext_glPixelTransferxOES,
    wow64_ext_glPixelTransformParameterfEXT,
    wow64_ext_glPixelTransformParameterfvEXT,
    wow64_ext_glPixelTransformParameteriEXT,
    wow64_ext_glPixelTransformParameterivEXT,
    wow64_ext_glPixelZoomxOES,
    wow64_ext_glPointAlongPathNV,
    wow64_ext_glPointParameterf,
    wow64_ext_glPointParameterfARB,
    wow64_ext_glPointParameterfEXT,
    wow64_ext_glPointParameterfSGIS,
    wow64_ext_glPointParameterfv,
    wow64_ext_glPointParameterfvARB,
    wow64_ext_glPointParameterfvEXT,
    wow64_ext_glPointParameterfvSGIS,
    wow64_ext_glPointParameteri,
    wow64_ext_glPointParameteriNV,
    wow64_ext_glPointParameteriv,
    wow64_ext_glPointParameterivNV,
    wow64_ext_glPointParameterx,
    wow64_ext_glPointParameterxv,
    wow64_ext_glPointParameterxvOES,
    wow64_ext_glPointSizex,
    wow64_ext_glPointSizexOES,
    wow64_ext_glPollAsyncSGIX,
    wow64_ext_glPollInstrumentsSGIX,
    wow64_ext_glPolygonOffsetClamp,
    wow64_ext_glPolygonOffsetClampEXT,
    wow64_ext_glPolygonOffsetEXT,
    wow64_ext_glPolygonOffsetx,
    wow64_ext_glPolygonOffsetxOES,
    wow64_ext_glPopDebugGroup,
    wow64_ext_glPopGroupMarkerEXT,
    wow64_ext_glPresentFrameDualFillNV,
    wow64_ext_glPresentFrameKeyedNV,
    wow64_ext_glPrimitiveBoundingBox,
    wow64_ext_glPrimitiveBoundingBoxARB,
    wow64_ext_glPrimitiveRestartIndex,
    wow64_ext_glPrimitiveRestartIndexNV,
    wow64_ext_glPrimitiveRestartNV,
    wow64_ext_glPrioritizeTexturesEXT,
    wow64_ext_glPrioritizeTexturesxOES,
    wow64_ext_glProgramBinary,
    wow64_ext_glProgramBufferParametersIivNV,
    wow64_ext_glProgramBufferParametersIuivNV,
    wow64_ext_glProgramBufferParametersfvNV,
    wow64_ext_glProgramEnvParameter4dARB,
    wow64_ext_glProgramEnvParameter4dvARB,
    wow64_ext_glProgramEnvParameter4fARB,
    wow64_ext_glProgramEnvParameter4fvARB,
    wow64_ext_glProgramEnvParameterI4iNV,
    wow64_ext_glProgramEnvParameterI4ivNV,
    wow64_ext_glProgramEnvParameterI4uiNV,
    wow64_ext_glProgramEnvParameterI4uivNV,
    wow64_ext_glProgramEnvParameters4fvEXT,
    wow64_ext_glProgramEnvParametersI4ivNV,
    wow64_ext_glProgramEnvParametersI4uivNV,
    wow64_ext_glProgramLocalParameter4dARB,
    wow64_ext_glProgramLocalParameter4dvARB,
    wow64_ext_glProgramLocalParameter4fARB,
    wow64_ext_glProgramLocalParameter4fvARB,
    wow64_ext_glProgramLocalParameterI4iNV,
    wow64_ext_glProgramLocalParameterI4ivNV,
    wow64_ext_glProgramLocalParameterI4uiNV,
    wow64_ext_glProgramLocalParameterI4uivNV,
    wow64_ext_glProgramLocalParameters4fvEXT,
    wow64_ext_glProgramLocalParametersI4ivNV,
    wow64_ext_glProgramLocalParametersI4uivNV,
    wow64_ext_glProgramNamedParameter4dNV,
    wow64_ext_glProgramNamedParameter4dvNV,
    wow64_ext_glProgramNamedParameter4fNV,
    wow64_ext_glProgramNamedParameter4fvNV,
    wow64_ext_glProgramParameter4dNV,
    wow64_ext_glProgramParameter4dvNV,
    wow64_ext_glProgramParameter4fNV,
    wow64_ext_glProgramParameter4fvNV,
    wow64_ext_glProgramParameteri,
    wow64_ext_glProgramParameteriARB,
    wow64_ext_glProgramParameteriEXT,
    wow64_ext_glProgramParameters4dvNV,
    wow64_ext_glProgramParameters4fvNV,
    wow64_ext_glProgramPathFragmentInputGenNV,
    wow64_ext_glProgramStringARB,
    wow64_ext_glProgramSubroutineParametersuivNV,
    wow64_ext_glProgramUniform1d,
    wow64_ext_glProgramUniform1dEXT,
    wow64_ext_glProgramUniform1dv,
    wow64_ext_glProgramUniform1dvEXT,
    wow64_ext_glProgramUniform1f,
    wow64_ext_glProgramUniform1fEXT,
    wow64_ext_glProgramUniform1fv,
    wow64_ext_glProgramUniform1fvEXT,
    wow64_ext_glProgramUniform1i,
    wow64_ext_glProgramUniform1i64ARB,
    wow64_ext_glProgramUniform1i64NV,
    wow64_ext_glProgramUniform1i64vARB,
    wow64_ext_glProgramUniform1i64vNV,
    wow64_ext_glProgramUniform1iEXT,
    wow64_ext_glProgramUniform1iv,
    wow64_ext_glProgramUniform1ivEXT,
    wow64_ext_glProgramUniform1ui,
    wow64_ext_glProgramUniform1ui64ARB,
    wow64_ext_glProgramUniform1ui64NV,
    wow64_ext_glProgramUniform1ui64vARB,
    wow64_ext_glProgramUniform1ui64vNV,
    wow64_ext_glProgramUniform1uiEXT,
    wow64_ext_glProgramUniform1uiv,
    wow64_ext_glProgramUniform1uivEXT,
    wow64_ext_glProgramUniform2d,
    wow64_ext_glProgramUniform2dEXT,
    wow64_ext_glProgramUniform2dv,
    wow64_ext_glProgramUniform2dvEXT,
    wow64_ext_glProgramUniform2f,
    wow64_ext_glProgramUniform2fEXT,
    wow64_ext_glProgramUniform2fv,
    wow64_ext_glProgramUniform2fvEXT,
    wow64_ext_glProgramUniform2i,
    wow64_ext_glProgramUniform2i64ARB,
    wow64_ext_glProgramUniform2i64NV,
    wow64_ext_glProgramUniform2i64vARB,
    wow64_ext_glProgramUniform2i64vNV,
    wow64_ext_glProgramUniform2iEXT,
    wow64_ext_glProgramUniform2iv,
    wow64_ext_glProgramUniform2ivEXT,
    wow64_ext_glProgramUniform2ui,
    wow64_ext_glProgramUniform2ui64ARB,
    wow64_ext_glProgramUniform2ui64NV,
    wow64_ext_glProgramUniform2ui64vARB,
    wow64_ext_glProgramUniform2ui64vNV,
    wow64_ext_glProgramUniform2uiEXT,
    wow64_ext_glProgramUniform2uiv,
    wow64_ext_glProgramUniform2uivEXT,
    wow64_ext_glProgramUniform3d,
    wow64_ext_glProgramUniform3dEXT,
    wow64_ext_glProgramUniform3dv,
    wow64_ext_glProgramUniform3dvEXT,
    wow64_ext_glProgramUniform3f,
    wow64_ext_glProgramUniform3fEXT,
    wow64_ext_glProgramUniform3fv,
    wow64_ext_glProgramUniform3fvEXT,
    wow64_ext_glProgramUniform3i,
    wow64_ext_glProgramUniform3i64ARB,
    wow64_ext_glProgramUniform3i64NV,
    wow64_ext_glProgramUniform3i64vARB,
    wow64_ext_glProgramUniform3i64vNV,
    wow64_ext_glProgramUniform3iEXT,
    wow64_ext_glProgramUniform3iv,
    wow64_ext_glProgramUniform3ivEXT,
    wow64_ext_glProgramUniform3ui,
    wow64_ext_glProgramUniform3ui64ARB,
    wow64_ext_glProgramUniform3ui64NV,
    wow64_ext_glProgramUniform3ui64vARB,
    wow64_ext_glProgramUniform3ui64vNV,
    wow64_ext_glProgramUniform3uiEXT,
    wow64_ext_glProgramUniform3uiv,
    wow64_ext_glProgramUniform3uivEXT,
    wow64_ext_glProgramUniform4d,
    wow64_ext_glProgramUniform4dEXT,
    wow64_ext_glProgramUniform4dv,
    wow64_ext_glProgramUniform4dvEXT,
    wow64_ext_glProgramUniform4f,
    wow64_ext_glProgramUniform4fEXT,
    wow64_ext_glProgramUniform4fv,
    wow64_ext_glProgramUniform4fvEXT,
    wow64_ext_glProgramUniform4i,
    wow64_ext_glProgramUniform4i64ARB,
    wow64_ext_glProgramUniform4i64NV,
    wow64_ext_glProgramUniform4i64vARB,
    wow64_ext_glProgramUniform4i64vNV,
    wow64_ext_glProgramUniform4iEXT,
    wow64_ext_glProgramUniform4iv,
    wow64_ext_glProgramUniform4ivEXT,
    wow64_ext_glProgramUniform4ui,
    wow64_ext_glProgramUniform4ui64ARB,
    wow64_ext_glProgramUniform4ui64NV,
    wow64_ext_glProgramUniform4ui64vARB,
    wow64_ext_glProgramUniform4ui64vNV,
    wow64_ext_glProgramUniform4uiEXT,
    wow64_ext_glProgramUniform4uiv,
    wow64_ext_glProgramUniform4uivEXT,
    wow64_ext_glProgramUniformHandleui64ARB,
    wow64_ext_glProgramUniformHandleui64NV,
    wow64_ext_glProgramUniformHandleui64vARB,
    wow64_ext_glProgramUniformHandleui64vNV,
    wow64_ext_glProgramUniformMatrix2dv,
    wow64_ext_glProgramUniformMatrix2dvEXT,
    wow64_ext_glProgramUniformMatrix2fv,
    wow64_ext_glProgramUniformMatrix2fvEXT,
    wow64_ext_glProgramUniformMatrix2x3dv,
    wow64_ext_glProgramUniformMatrix2x3dvEXT,
    wow64_ext_glProgramUniformMatrix2x3fv,
    wow64_ext_glProgramUniformMatrix2x3fvEXT,
    wow64_ext_glProgramUniformMatrix2x4dv,
    wow64_ext_glProgramUniformMatrix2x4dvEXT,
    wow64_ext_glProgramUniformMatrix2x4fv,
    wow64_ext_glProgramUniformMatrix2x4fvEXT,
    wow64_ext_glProgramUniformMatrix3dv,
    wow64_ext_glProgramUniformMatrix3dvEXT,
    wow64_ext_glProgramUniformMatrix3fv,
    wow64_ext_glProgramUniformMatrix3fvEXT,
    wow64_ext_glProgramUniformMatrix3x2dv,
    wow64_ext_glProgramUniformMatrix3x2dvEXT,
    wow64_ext_glProgramUniformMatrix3x2fv,
    wow64_ext_glProgramUniformMatrix3x2fvEXT,
    wow64_ext_glProgramUniformMatrix3x4dv,
    wow64_ext_glProgramUniformMatrix3x4dvEXT,
    wow64_ext_glProgramUniformMatrix3x4fv,
    wow64_ext_glProgramUniformMatrix3x4fvEXT,
    wow64_ext_glProgramUniformMatrix4dv,
    wow64_ext_glProgramUniformMatrix4dvEXT,
    wow64_ext_glProgramUniformMatrix4fv,
    wow64_ext_glProgramUniformMatrix4fvEXT,
    wow64_ext_glProgramUniformMatrix4x2dv,
    wow64_ext_glProgramUniformMatrix4x2dvEXT,
    wow64_ext_glProgramUniformMatrix4x2fv,
    wow64_ext_glProgramUniformMatrix4x2fvEXT,
    wow64_ext_glProgramUniformMatrix4x3dv,
    wow64_ext_glProgramUniformMatrix4x3dvEXT,
    wow64_ext_glProgramUniformMatrix4x3fv,
    wow64_ext_glProgramUniformMatrix4x3fvEXT,
    wow64_ext_glProgramUniformui64NV,
    wow64_ext_glProgramUniformui64vNV,
    wow64_ext_glProgramVertexLimitNV,
    wow64_ext_glProvokingVertex,
    wow64_ext_glProvokingVertexEXT,
    wow64_ext_glPushClientAttribDefaultEXT,
    wow64_ext_glPushDebugGroup,
    wow64_ext_glPushGroupMarkerEXT,
    wow64_ext_glQueryCounter,
    wow64_ext_glQueryMatrixxOES,
    wow64_ext_glQueryObjectParameteruiAMD,
    wow64_ext_glQueryResourceNV,
    wow64_ext_glQueryResourceTagNV,
    wow64_ext_glRasterPos2xOES,
    wow64_ext_glRasterPos2xvOES,
    wow64_ext_glRasterPos3xOES,
    wow64_ext_glRasterPos3xvOES,
    wow64_ext_glRasterPos4xOES,
    wow64_ext_glRasterPos4xvOES,
    wow64_ext_glRasterSamplesEXT,
    wow64_ext_glReadBufferRegion,
    wow64_ext_glReadInstrumentsSGIX,
    wow64_ext_glReadnPixels,
    wow64_ext_glReadnPixelsARB,
    wow64_ext_glRectxOES,
    wow64_ext_glRectxvOES,
    wow64_ext_glReferencePlaneSGIX,
    wow64_ext_glReleaseKeyedMutexWin32EXT,
    wow64_ext_glReleaseShaderCompiler,
    wow64_ext_glRenderGpuMaskNV,
    wow64_ext_glRenderbufferStorage,
    wow64_ext_glRenderbufferStorageEXT,
    wow64_ext_glRenderbufferStorageMultisample,
    wow64_ext_glRenderbufferStorageMultisampleAdvancedAMD,
    wow64_ext_glRenderbufferStorageMultisampleCoverageNV,
    wow64_ext_glRenderbufferStorageMultisampleEXT,
    wow64_ext_glReplacementCodePointerSUN,
    wow64_ext_glReplacementCodeubSUN,
    wow64_ext_glReplacementCodeubvSUN,
    wow64_ext_glReplacementCodeuiColor3fVertex3fSUN,
    wow64_ext_glReplacementCodeuiColor3fVertex3fvSUN,
    wow64_ext_glReplacementCodeuiColor4fNormal3fVertex3fSUN,
    wow64_ext_glReplacementCodeuiColor4fNormal3fVertex3fvSUN,
    wow64_ext_glReplacementCodeuiColor4ubVertex3fSUN,
    wow64_ext_glReplacementCodeuiColor4ubVertex3fvSUN,
    wow64_ext_glReplacementCodeuiNormal3fVertex3fSUN,
    wow64_ext_glReplacementCodeuiNormal3fVertex3fvSUN,
    wow64_ext_glReplacementCodeuiSUN,
    wow64_ext_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN,
    wow64_ext_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN,
    wow64_ext_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN,
    wow64_ext_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN,
    wow64_ext_glReplacementCodeuiTexCoord2fVertex3fSUN,
    wow64_ext_glReplacementCodeuiTexCoord2fVertex3fvSUN,
    wow64_ext_glReplacementCodeuiVertex3fSUN,
    wow64_ext_glReplacementCodeuiVertex3fvSUN,
    wow64_ext_glReplacementCodeuivSUN,
    wow64_ext_glReplacementCodeusSUN,
    wow64_ext_glReplacementCodeusvSUN,
    wow64_ext_glRequestResidentProgramsNV,
    wow64_ext_glResetHistogram,
    wow64_ext_glResetHistogramEXT,
    wow64_ext_glResetMemoryObjectParameterNV,
    wow64_ext_glResetMinmax,
    wow64_ext_glResetMinmaxEXT,
    wow64_ext_glResizeBuffersMESA,
    wow64_ext_glResolveDepthValuesNV,
    wow64_ext_glResumeTransformFeedback,
    wow64_ext_glResumeTransformFeedbackNV,
    wow64_ext_glRotatex,
    wow64_ext_glRotatexOES,
    wow64_ext_glSampleCoverage,
    wow64_ext_glSampleCoverageARB,
    wow64_ext_glSampleCoveragex,
    wow64_ext_glSampleMapATI,
    wow64_ext_glSampleMaskEXT,
    wow64_ext_glSampleMaskIndexedNV,
    wow64_ext_glSampleMaskSGIS,
    wow64_ext_glSampleMaski,
    wow64_ext_glSamplePatternEXT,
    wow64_ext_glSamplePatternSGIS,
    wow64_ext_glSamplerParameterIiv,
    wow64_ext_glSamplerParameterIuiv,
    wow64_ext_glSamplerParameterf,
    wow64_ext_glSamplerParameterfv,
    wow64_ext_glSamplerParameteri,
    wow64_ext_glSamplerParameteriv,
    wow64_ext_glScalex,
    wow64_ext_glScalexOES,
    wow64_ext_glScissorArrayv,
    wow64_ext_glScissorExclusiveArrayvNV,
    wow64_ext_glScissorExclusiveNV,
    wow64_ext_glScissorIndexed,
    wow64_ext_glScissorIndexedv,
    wow64_ext_glSecondaryColor3b,
    wow64_ext_glSecondaryColor3bEXT,
    wow64_ext_glSecondaryColor3bv,
    wow64_ext_glSecondaryColor3bvEXT,
    wow64_ext_glSecondaryColor3d,
    wow64_ext_glSecondaryColor3dEXT,
    wow64_ext_glSecondaryColor3dv,
    wow64_ext_glSecondaryColor3dvEXT,
    wow64_ext_glSecondaryColor3f,
    wow64_ext_glSecondaryColor3fEXT,
    wow64_ext_glSecondaryColor3fv,
    wow64_ext_glSecondaryColor3fvEXT,
    wow64_ext_glSecondaryColor3hNV,
    wow64_ext_glSecondaryColor3hvNV,
    wow64_ext_glSecondaryColor3i,
    wow64_ext_glSecondaryColor3iEXT,
    wow64_ext_glSecondaryColor3iv,
    wow64_ext_glSecondaryColor3ivEXT,
    wow64_ext_glSecondaryColor3s,
    wow64_ext_glSecondaryColor3sEXT,
    wow64_ext_glSecondaryColor3sv,
    wow64_ext_glSecondaryColor3svEXT,
    wow64_ext_glSecondaryColor3ub,
    wow64_ext_glSecondaryColor3ubEXT,
    wow64_ext_glSecondaryColor3ubv,
    wow64_ext_glSecondaryColor3ubvEXT,
    wow64_ext_glSecondaryColor3ui,
    wow64_ext_glSecondaryColor3uiEXT,
    wow64_ext_glSecondaryColor3uiv,
    wow64_ext_glSecondaryColor3uivEXT,
    wow64_ext_glSecondaryColor3us,
    wow64_ext_glSecondaryColor3usEXT,
    wow64_ext_glSecondaryColor3usv,
    wow64_ext_glSecondaryColor3usvEXT,
    wow64_ext_glSecondaryColorFormatNV,
    wow64_ext_glSecondaryColorP3ui,
    wow64_ext_glSecondaryColorP3uiv,
    wow64_ext_glSecondaryColorPointer,
    wow64_ext_glSecondaryColorPointerEXT,
    wow64_ext_glSecondaryColorPointerListIBM,
    wow64_ext_glSelectPerfMonitorCountersAMD,
    wow64_ext_glSelectTextureCoordSetSGIS,
    wow64_ext_glSelectTextureSGIS,
    wow64_ext_glSemaphoreParameterivNV,
    wow64_ext_glSemaphoreParameterui64vEXT,
    wow64_ext_glSeparableFilter2D,
    wow64_ext_glSeparableFilter2DEXT,
    wow64_ext_glSetFenceAPPLE,
    wow64_ext_glSetFenceNV,
    wow64_ext_glSetFragmentShaderConstantATI,
    wow64_ext_glSetInvariantEXT,
    wow64_ext_glSetLocalConstantEXT,
    wow64_ext_glSetMultisamplefvAMD,
    wow64_ext_glShaderBinary,
    wow64_ext_glShaderOp1EXT,
    wow64_ext_glShaderOp2EXT,
    wow64_ext_glShaderOp3EXT,
    wow64_ext_glShaderSource,
    wow64_ext_glShaderSourceARB,
    wow64_ext_glShaderStorageBlockBinding,
    wow64_ext_glShadingRateCombinerOpsEXT,
    wow64_ext_glShadingRateEXT,
    wow64_ext_glShadingRateImageBarrierNV,
    wow64_ext_glShadingRateImagePaletteNV,
    wow64_ext_glShadingRateSampleOrderCustomNV,
    wow64_ext_glShadingRateSampleOrderNV,
    wow64_ext_glSharpenTexFuncSGIS,
    wow64_ext_glSignalSemaphoreEXT,
    wow64_ext_glSignalSemaphoreui64NVX,
    wow64_ext_glSignalVkFenceNV,
    wow64_ext_glSignalVkSemaphoreNV,
    wow64_ext_glSpecializeShader,
    wow64_ext_glSpecializeShaderARB,
    wow64_ext_glSpriteParameterfSGIX,
    wow64_ext_glSpriteParameterfvSGIX,
    wow64_ext_glSpriteParameteriSGIX,
    wow64_ext_glSpriteParameterivSGIX,
    wow64_ext_glStartInstrumentsSGIX,
    wow64_ext_glStateCaptureNV,
    wow64_ext_glStencilClearTagEXT,
    wow64_ext_glStencilFillPathInstancedNV,
    wow64_ext_glStencilFillPathNV,
    wow64_ext_glStencilFuncSeparate,
    wow64_ext_glStencilFuncSeparateATI,
    wow64_ext_glStencilMaskSeparate,
    wow64_ext_glStencilOpSeparate,
    wow64_ext_glStencilOpSeparateATI,
    wow64_ext_glStencilOpValueAMD,
    wow64_ext_glStencilStrokePathInstancedNV,
    wow64_ext_glStencilStrokePathNV,
    wow64_ext_glStencilThenCoverFillPathInstancedNV,
    wow64_ext_glStencilThenCoverFillPathNV,
    wow64_ext_glStencilThenCoverStrokePathInstancedNV,
    wow64_ext_glStencilThenCoverStrokePathNV,
    wow64_ext_glStopInstrumentsSGIX,
    wow64_ext_glStringMarkerGREMEDY,
    wow64_ext_glSubpixelPrecisionBiasNV,
    wow64_ext_glSwizzleEXT,
    wow64_ext_glSyncTextureINTEL,
    wow64_ext_glTagSampleBufferSGIX,
    wow64_ext_glTangent3bEXT,
    wow64_ext_glTangent3bvEXT,
    wow64_ext_glTangent3dEXT,
    wow64_ext_glTangent3dvEXT,
    wow64_ext_glTangent3fEXT,
    wow64_ext_glTangent3fvEXT,
    wow64_ext_glTangent3iEXT,
    wow64_ext_glTangent3ivEXT,
    wow64_ext_glTangent3sEXT,
    wow64_ext_glTangent3svEXT,
    wow64_ext_glTangentPointerEXT,
    wow64_ext_glTbufferMask3DFX,
    wow64_ext_glTessellationFactorAMD,
    wow64_ext_glTessellationModeAMD,
    wow64_ext_glTestFenceAPPLE,
    wow64_ext_glTestFenceNV,
    wow64_ext_glTestObjectAPPLE,
    wow64_ext_glTexAttachMemoryNV,
    wow64_ext_glTexBuffer,
    wow64_ext_glTexBufferARB,
    wow64_ext_glTexBufferEXT,
    wow64_ext_glTexBufferRange,
    wow64_ext_glTexBumpParameterfvATI,
    wow64_ext_glTexBumpParameterivATI,
    wow64_ext_glTexCoord1bOES,
    wow64_ext_glTexCoord1bvOES,
    wow64_ext_glTexCoord1hNV,
    wow64_ext_glTexCoord1hvNV,
    wow64_ext_glTexCoord1xOES,
    wow64_ext_glTexCoord1xvOES,
    wow64_ext_glTexCoord2bOES,
    wow64_ext_glTexCoord2bvOES,
    wow64_ext_glTexCoord2fColor3fVertex3fSUN,
    wow64_ext_glTexCoord2fColor3fVertex3fvSUN,
    wow64_ext_glTexCoord2fColor4fNormal3fVertex3fSUN,
    wow64_ext_glTexCoord2fColor4fNormal3fVertex3fvSUN,
    wow64_ext_glTexCoord2fColor4ubVertex3fSUN,
    wow64_ext_glTexCoord2fColor4ubVertex3fvSUN,
    wow64_ext_glTexCoord2fNormal3fVertex3fSUN,
    wow64_ext_glTexCoord2fNormal3fVertex3fvSUN,
    wow64_ext_glTexCoord2fVertex3fSUN,
    wow64_ext_glTexCoord2fVertex3fvSUN,
    wow64_ext_glTexCoord2hNV,
    wow64_ext_glTexCoord2hvNV,
    wow64_ext_glTexCoord2xOES,
    wow64_ext_glTexCoord2xvOES,
    wow64_ext_glTexCoord3bOES,
    wow64_ext_glTexCoord3bvOES,
    wow64_ext_glTexCoord3hNV,
    wow64_ext_glTexCoord3hvNV,
    wow64_ext_glTexCoord3xOES,
    wow64_ext_glTexCoord3xvOES,
    wow64_ext_glTexCoord4bOES,
    wow64_ext_glTexCoord4bvOES,
    wow64_ext_glTexCoord4fColor4fNormal3fVertex4fSUN,
    wow64_ext_glTexCoord4fColor4fNormal3fVertex4fvSUN,
    wow64_ext_glTexCoord4fVertex4fSUN,
    wow64_ext_glTexCoord4fVertex4fvSUN,
    wow64_ext_glTexCoord4hNV,
    wow64_ext_glTexCoord4hvNV,
    wow64_ext_glTexCoord4xOES,
    wow64_ext_glTexCoord4xvOES,
    wow64_ext_glTexCoordFormatNV,
    wow64_ext_glTexCoordP1ui,
    wow64_ext_glTexCoordP1uiv,
    wow64_ext_glTexCoordP2ui,
    wow64_ext_glTexCoordP2uiv,
    wow64_ext_glTexCoordP3ui,
    wow64_ext_glTexCoordP3uiv,
    wow64_ext_glTexCoordP4ui,
    wow64_ext_glTexCoordP4uiv,
    wow64_ext_glTexCoordPointerEXT,
    wow64_ext_glTexCoordPointerListIBM,
    wow64_ext_glTexCoordPointervINTEL,
    wow64_ext_glTexEnvx,
    wow64_ext_glTexEnvxOES,
    wow64_ext_glTexEnvxv,
    wow64_ext_glTexEnvxvOES,
    wow64_ext_glTexFilterFuncSGIS,
    wow64_ext_glTexGenxOES,
    wow64_ext_glTexGenxvOES,
    wow64_ext_glTexImage2DMultisample,
    wow64_ext_glTexImage2DMultisampleCoverageNV,
    wow64_ext_glTexImage3D,
    wow64_ext_glTexImage3DEXT,
    wow64_ext_glTexImage3DMultisample,
    wow64_ext_glTexImage3DMultisampleCoverageNV,
    wow64_ext_glTexImage4DSGIS,
    wow64_ext_glTexPageCommitmentARB,
    wow64_ext_glTexPageCommitmentMemNV,
    wow64_ext_glTexParameterIiv,
    wow64_ext_glTexParameterIivEXT,
    wow64_ext_glTexParameterIuiv,
    wow64_ext_glTexParameterIuivEXT,
    wow64_ext_glTexParameterx,
    wow64_ext_glTexParameterxOES,
    wow64_ext_glTexParameterxv,
    wow64_ext_glTexParameterxvOES,
    wow64_ext_glTexRenderbufferNV,
    wow64_ext_glTexStorage1D,
    wow64_ext_glTexStorage1DEXT,
    wow64_ext_glTexStorage2D,
    wow64_ext_glTexStorage2DEXT,
    wow64_ext_glTexStorage2DMultisample,
    wow64_ext_glTexStorage3D,
    wow64_ext_glTexStorage3DEXT,
    wow64_ext_glTexStorage3DMultisample,
    wow64_ext_glTexStorageMem1DEXT,
    wow64_ext_glTexStorageMem2DEXT,
    wow64_ext_glTexStorageMem2DMultisampleEXT,
    wow64_ext_glTexStorageMem3DEXT,
    wow64_ext_glTexStorageMem3DMultisampleEXT,
    wow64_ext_glTexStorageSparseAMD,
    wow64_ext_glTexSubImage1DEXT,
    wow64_ext_glTexSubImage2DEXT,
    wow64_ext_glTexSubImage3D,
    wow64_ext_glTexSubImage3DEXT,
    wow64_ext_glTexSubImage4DSGIS,
    wow64_ext_glTextureAttachMemoryNV,
    wow64_ext_glTextureBarrier,
    wow64_ext_glTextureBarrierNV,
    wow64_ext_glTextureBuffer,
    wow64_ext_glTextureBufferEXT,
    wow64_ext_glTextureBufferRange,
    wow64_ext_glTextureBufferRangeEXT,
    wow64_ext_glTextureColorMaskSGIS,
    wow64_ext_glTextureImage1DEXT,
    wow64_ext_glTextureImage2DEXT,
    wow64_ext_glTextureImage2DMultisampleCoverageNV,
    wow64_ext_glTextureImage2DMultisampleNV,
    wow64_ext_glTextureImage3DEXT,
    wow64_ext_glTextureImage3DMultisampleCoverageNV,
    wow64_ext_glTextureImage3DMultisampleNV,
    wow64_ext_glTextureLightEXT,
    wow64_ext_glTextureMaterialEXT,
    wow64_ext_glTextureNormalEXT,
    wow64_ext_glTexturePageCommitmentEXT,
    wow64_ext_glTexturePageCommitmentMemNV,
    wow64_ext_glTextureParameterIiv,
    wow64_ext_glTextureParameterIivEXT,
    wow64_ext_glTextureParameterIuiv,
    wow64_ext_glTextureParameterIuivEXT,
    wow64_ext_glTextureParameterf,
    wow64_ext_glTextureParameterfEXT,
    wow64_ext_glTextureParameterfv,
    wow64_ext_glTextureParameterfvEXT,
    wow64_ext_glTextureParameteri,
    wow64_ext_glTextureParameteriEXT,
    wow64_ext_glTextureParameteriv,
    wow64_ext_glTextureParameterivEXT,
    wow64_ext_glTextureRangeAPPLE,
    wow64_ext_glTextureRenderbufferEXT,
    wow64_ext_glTextureStorage1D,
    wow64_ext_glTextureStorage1DEXT,
    wow64_ext_glTextureStorage2D,
    wow64_ext_glTextureStorage2DEXT,
    wow64_ext_glTextureStorage2DMultisample,
    wow64_ext_glTextureStorage2DMultisampleEXT,
    wow64_ext_glTextureStorage3D,
    wow64_ext_glTextureStorage3DEXT,
    wow64_ext_glTextureStorage3DMultisample,
    wow64_ext_glTextureStorage3DMultisampleEXT,
    wow64_ext_glTextureStorageMem1DEXT,
    wow64_ext_glTextureStorageMem2DEXT,
    wow64_ext_glTextureStorageMem2DMultisampleEXT,
    wow64_ext_glTextureStorageMem3DEXT,
    wow64_ext_glTextureStorageMem3DMultisampleEXT,
    wow64_ext_glTextureStorageSparseAMD,
    wow64_ext_glTextureSubImage1D,
    wow64_ext_glTextureSubImage1DEXT,
    wow64_ext_glTextureSubImage2D,
    wow64_ext_glTextureSubImage2DEXT,
    wow64_ext_glTextureSubImage3D,
    wow64_ext_glTextureSubImage3DEXT,
    wow64_ext_glTextureView,
    wow64_ext_glTrackMatrixNV,
    wow64_ext_glTransformFeedbackAttribsNV,
    wow64_ext_glTransformFeedbackBufferBase,
    wow64_ext_glTransformFeedbackBufferRange,
    wow64_ext_glTransformFeedbackStreamAttribsNV,
    wow64_ext_glTransformFeedbackVaryings,
    wow64_ext_glTransformFeedbackVaryingsEXT,
    wow64_ext_glTransformFeedbackVaryingsNV,
    wow64_ext_glTransformPathNV,
    wow64_ext_glTranslatex,
    wow64_ext_glTranslatexOES,
    wow64_ext_glUniform1d,
    wow64_ext_glUniform1dv,
    wow64_ext_glUniform1f,
    wow64_ext_glUniform1fARB,
    wow64_ext_glUniform1fv,
    wow64_ext_glUniform1fvARB,
    wow64_ext_glUniform1i,
    wow64_ext_glUniform1i64ARB,
    wow64_ext_glUniform1i64NV,
    wow64_ext_glUniform1i64vARB,
    wow64_ext_glUniform1i64vNV,
    wow64_ext_glUniform1iARB,
    wow64_ext_glUniform1iv,
    wow64_ext_glUniform1ivARB,
    wow64_ext_glUniform1ui,
    wow64_ext_glUniform1ui64ARB,
    wow64_ext_glUniform1ui64NV,
    wow64_ext_glUniform1ui64vARB,
    wow64_ext_glUniform1ui64vNV,
    wow64_ext_glUniform1uiEXT,
    wow64_ext_glUniform1uiv,
    wow64_ext_glUniform1uivEXT,
    wow64_ext_glUniform2d,
    wow64_ext_glUniform2dv,
    wow64_ext_glUniform2f,
    wow64_ext_glUniform2fARB,
    wow64_ext_glUniform2fv,
    wow64_ext_glUniform2fvARB,
    wow64_ext_glUniform2i,
    wow64_ext_glUniform2i64ARB,
    wow64_ext_glUniform2i64NV,
    wow64_ext_glUniform2i64vARB,
    wow64_ext_glUniform2i64vNV,
    wow64_ext_glUniform2iARB,
    wow64_ext_glUniform2iv,
    wow64_ext_glUniform2ivARB,
    wow64_ext_glUniform2ui,
    wow64_ext_glUniform2ui64ARB,
    wow64_ext_glUniform2ui64NV,
    wow64_ext_glUniform2ui64vARB,
    wow64_ext_glUniform2ui64vNV,
    wow64_ext_glUniform2uiEXT,
    wow64_ext_glUniform2uiv,
    wow64_ext_glUniform2uivEXT,
    wow64_ext_glUniform3d,
    wow64_ext_glUniform3dv,
    wow64_ext_glUniform3f,
    wow64_ext_glUniform3fARB,
    wow64_ext_glUniform3fv,
    wow64_ext_glUniform3fvARB,
    wow64_ext_glUniform3i,
    wow64_ext_glUniform3i64ARB,
    wow64_ext_glUniform3i64NV,
    wow64_ext_glUniform3i64vARB,
    wow64_ext_glUniform3i64vNV,
    wow64_ext_glUniform3iARB,
    wow64_ext_glUniform3iv,
    wow64_ext_glUniform3ivARB,
    wow64_ext_glUniform3ui,
    wow64_ext_glUniform3ui64ARB,
    wow64_ext_glUniform3ui64NV,
    wow64_ext_glUniform3ui64vARB,
    wow64_ext_glUniform3ui64vNV,
    wow64_ext_glUniform3uiEXT,
    wow64_ext_glUniform3uiv,
    wow64_ext_glUniform3uivEXT,
    wow64_ext_glUniform4d,
    wow64_ext_glUniform4dv,
    wow64_ext_glUniform4f,
    wow64_ext_glUniform4fARB,
    wow64_ext_glUniform4fv,
    wow64_ext_glUniform4fvARB,
    wow64_ext_glUniform4i,
    wow64_ext_glUniform4i64ARB,
    wow64_ext_glUniform4i64NV,
    wow64_ext_glUniform4i64vARB,
    wow64_ext_glUniform4i64vNV,
    wow64_ext_glUniform4iARB,
    wow64_ext_glUniform4iv,
    wow64_ext_glUniform4ivARB,
    wow64_ext_glUniform4ui,
    wow64_ext_glUniform4ui64ARB,
    wow64_ext_glUniform4ui64NV,
    wow64_ext_glUniform4ui64vARB,
    wow64_ext_glUniform4ui64vNV,
    wow64_ext_glUniform4uiEXT,
    wow64_ext_glUniform4uiv,
    wow64_ext_glUniform4uivEXT,
    wow64_ext_glUniformBlockBinding,
    wow64_ext_glUniformBufferEXT,
    wow64_ext_glUniformHandleui64ARB,
    wow64_ext_glUniformHandleui64NV,
    wow64_ext_glUniformHandleui64vARB,
    wow64_ext_glUniformHandleui64vNV,
    wow64_ext_glUniformMatrix2dv,
    wow64_ext_glUniformMatrix2fv,
    wow64_ext_glUniformMatrix2fvARB,
    wow64_ext_glUniformMatrix2x3dv,
    wow64_ext_glUniformMatrix2x3fv,
    wow64_ext_glUniformMatrix2x4dv,
    wow64_ext_glUniformMatrix2x4fv,
    wow64_ext_glUniformMatrix3dv,
    wow64_ext_glUniformMatrix3fv,
    wow64_ext_glUniformMatrix3fvARB,
    wow64_ext_glUniformMatrix3x2dv,
    wow64_ext_glUniformMatrix3x2fv,
    wow64_ext_glUniformMatrix3x4dv,
    wow64_ext_glUniformMatrix3x4fv,
    wow64_ext_glUniformMatrix4dv,
    wow64_ext_glUniformMatrix4fv,
    wow64_ext_glUniformMatrix4fvARB,
    wow64_ext_glUniformMatrix4x2dv,
    wow64_ext_glUniformMatrix4x2fv,
    wow64_ext_glUniformMatrix4x3dv,
    wow64_ext_glUniformMatrix4x3fv,
    wow64_ext_glUniformSubroutinesuiv,
    wow64_ext_glUniformui64NV,
    wow64_ext_glUniformui64vNV,
    wow64_ext_glUnlockArraysEXT,
    wow64_ext_glUnmapBuffer,
    wow64_ext_glUnmapBufferARB,
    wow64_ext_glUnmapNamedBuffer,
    wow64_ext_glUnmapNamedBufferEXT,
    wow64_ext_glUnmapObjectBufferATI,
    wow64_ext_glUnmapTexture2DINTEL,
    wow64_ext_glUpdateObjectBufferATI,
    wow64_ext_glUploadGpuMaskNVX,
    wow64_ext_glUseProgram,
    wow64_ext_glUseProgramObjectARB,
    wow64_ext_glUseProgramStages,
    wow64_ext_glUseShaderProgramEXT,
    wow64_ext_glVDPAUFiniNV,
    wow64_ext_glVDPAUGetSurfaceivNV,
    wow64_ext_glVDPAUInitNV,
    wow64_ext_glVDPAUIsSurfaceNV,
    wow64_ext_glVDPAUMapSurfacesNV,
    wow64_ext_glVDPAURegisterOutputSurfaceNV,
    wow64_ext_glVDPAURegisterVideoSurfaceNV,
    wow64_ext_glVDPAURegisterVideoSurfaceWithPictureStructureNV,
    wow64_ext_glVDPAUSurfaceAccessNV,
    wow64_ext_glVDPAUUnmapSurfacesNV,
    wow64_ext_glVDPAUUnregisterSurfaceNV,
    wow64_ext_glValidateProgram,
    wow64_ext_glValidateProgramARB,
    wow64_ext_glValidateProgramPipeline,
    wow64_ext_glVariantArrayObjectATI,
    wow64_ext_glVariantPointerEXT,
    wow64_ext_glVariantbvEXT,
    wow64_ext_glVariantdvEXT,
    wow64_ext_glVariantfvEXT,
    wow64_ext_glVariantivEXT,
    wow64_ext_glVariantsvEXT,
    wow64_ext_glVariantubvEXT,
    wow64_ext_glVariantuivEXT,
    wow64_ext_glVariantusvEXT,
    wow64_ext_glVertex2bOES,
    wow64_ext_glVertex2bvOES,
    wow64_ext_glVertex2hNV,
    wow64_ext_glVertex2hvNV,
    wow64_ext_glVertex2xOES,
    wow64_ext_glVertex2xvOES,
    wow64_ext_glVertex3bOES,
    wow64_ext_glVertex3bvOES,
    wow64_ext_glVertex3hNV,
    wow64_ext_glVertex3hvNV,
    wow64_ext_glVertex3xOES,
    wow64_ext_glVertex3xvOES,
    wow64_ext_glVertex4bOES,
    wow64_ext_glVertex4bvOES,
    wow64_ext_glVertex4hNV,
    wow64_ext_glVertex4hvNV,
    wow64_ext_glVertex4xOES,
    wow64_ext_glVertex4xvOES,
    wow64_ext_glVertexArrayAttribBinding,
    wow64_ext_glVertexArrayAttribFormat,
    wow64_ext_glVertexArrayAttribIFormat,
    wow64_ext_glVertexArrayAttribLFormat,
    wow64_ext_glVertexArrayBindVertexBufferEXT,
    wow64_ext_glVertexArrayBindingDivisor,
    wow64_ext_glVertexArrayColorOffsetEXT,
    wow64_ext_glVertexArrayEdgeFlagOffsetEXT,
    wow64_ext_glVertexArrayElementBuffer,
    wow64_ext_glVertexArrayFogCoordOffsetEXT,
    wow64_ext_glVertexArrayIndexOffsetEXT,
    wow64_ext_glVertexArrayMultiTexCoordOffsetEXT,
    wow64_ext_glVertexArrayNormalOffsetEXT,
    wow64_ext_glVertexArrayParameteriAPPLE,
    wow64_ext_glVertexArrayRangeAPPLE,
    wow64_ext_glVertexArrayRangeNV,
    wow64_ext_glVertexArraySecondaryColorOffsetEXT,
    wow64_ext_glVertexArrayTexCoordOffsetEXT,
    wow64_ext_glVertexArrayVertexAttribBindingEXT,
    wow64_ext_glVertexArrayVertexAttribDivisorEXT,
    wow64_ext_glVertexArrayVertexAttribFormatEXT,
    wow64_ext_glVertexArrayVertexAttribIFormatEXT,
    wow64_ext_glVertexArrayVertexAttribIOffsetEXT,
    wow64_ext_glVertexArrayVertexAttribLFormatEXT,
    wow64_ext_glVertexArrayVertexAttribLOffsetEXT,
    wow64_ext_glVertexArrayVertexAttribOffsetEXT,
    wow64_ext_glVertexArrayVertexBindingDivisorEXT,
    wow64_ext_glVertexArrayVertexBuffer,
    wow64_ext_glVertexArrayVertexBuffers,
    wow64_ext_glVertexArrayVertexOffsetEXT,
    wow64_ext_glVertexAttrib1d,
    wow64_ext_glVertexAttrib1dARB,
    wow64_ext_glVertexAttrib1dNV,
    wow64_ext_glVertexAttrib1dv,
    wow64_ext_glVertexAttrib1dvARB,
    wow64_ext_glVertexAttrib1dvNV,
    wow64_ext_glVertexAttrib1f,
    wow64_ext_glVertexAttrib1fARB,
    wow64_ext_glVertexAttrib1fNV,
    wow64_ext_glVertexAttrib1fv,
    wow64_ext_glVertexAttrib1fvARB,
    wow64_ext_glVertexAttrib1fvNV,
    wow64_ext_glVertexAttrib1hNV,
    wow64_ext_glVertexAttrib1hvNV,
    wow64_ext_glVertexAttrib1s,
    wow64_ext_glVertexAttrib1sARB,
    wow64_ext_glVertexAttrib1sNV,
    wow64_ext_glVertexAttrib1sv,
    wow64_ext_glVertexAttrib1svARB,
    wow64_ext_glVertexAttrib1svNV,
    wow64_ext_glVertexAttrib2d,
    wow64_ext_glVertexAttrib2dARB,
    wow64_ext_glVertexAttrib2dNV,
    wow64_ext_glVertexAttrib2dv,
    wow64_ext_glVertexAttrib2dvARB,
    wow64_ext_glVertexAttrib2dvNV,
    wow64_ext_glVertexAttrib2f,
    wow64_ext_glVertexAttrib2fARB,
    wow64_ext_glVertexAttrib2fNV,
    wow64_ext_glVertexAttrib2fv,
    wow64_ext_glVertexAttrib2fvARB,
    wow64_ext_glVertexAttrib2fvNV,
    wow64_ext_glVertexAttrib2hNV,
    wow64_ext_glVertexAttrib2hvNV,
    wow64_ext_glVertexAttrib2s,
    wow64_ext_glVertexAttrib2sARB,
    wow64_ext_glVertexAttrib2sNV,
    wow64_ext_glVertexAttrib2sv,
    wow64_ext_glVertexAttrib2svARB,
    wow64_ext_glVertexAttrib2svNV,
    wow64_ext_glVertexAttrib3d,
    wow64_ext_glVertexAttrib3dARB,
    wow64_ext_glVertexAttrib3dNV,
    wow64_ext_glVertexAttrib3dv,
    wow64_ext_glVertexAttrib3dvARB,
    wow64_ext_glVertexAttrib3dvNV,
    wow64_ext_glVertexAttrib3f,
    wow64_ext_glVertexAttrib3fARB,
    wow64_ext_glVertexAttrib3fNV,
    wow64_ext_glVertexAttrib3fv,
    wow64_ext_glVertexAttrib3fvARB,
    wow64_ext_glVertexAttrib3fvNV,
    wow64_ext_glVertexAttrib3hNV,
    wow64_ext_glVertexAttrib3hvNV,
    wow64_ext_glVertexAttrib3s,
    wow64_ext_glVertexAttrib3sARB,
    wow64_ext_glVertexAttrib3sNV,
    wow64_ext_glVertexAttrib3sv,
    wow64_ext_glVertexAttrib3svARB,
    wow64_ext_glVertexAttrib3svNV,
    wow64_ext_glVertexAttrib4Nbv,
    wow64_ext_glVertexAttrib4NbvARB,
    wow64_ext_glVertexAttrib4Niv,
    wow64_ext_glVertexAttrib4NivARB,
    wow64_ext_glVertexAttrib4Nsv,
    wow64_ext_glVertexAttrib4NsvARB,
    wow64_ext_glVertexAttrib4Nub,
    wow64_ext_glVertexAttrib4NubARB,
    wow64_ext_glVertexAttrib4Nubv,
    wow64_ext_glVertexAttrib4NubvARB,
    wow64_ext_glVertexAttrib4Nuiv,
    wow64_ext_glVertexAttrib4NuivARB,
    wow64_ext_glVertexAttrib4Nusv,
    wow64_ext_glVertexAttrib4NusvARB,
    wow64_ext_glVertexAttrib4bv,
    wow64_ext_glVertexAttrib4bvARB,
    wow64_ext_glVertexAttrib4d,
    wow64_ext_glVertexAttrib4dARB,
    wow64_ext_glVertexAttrib4dNV,
    wow64_ext_glVertexAttrib4dv,
    wow64_ext_glVertexAttrib4dvARB,
    wow64_ext_glVertexAttrib4dvNV,
    wow64_ext_glVertexAttrib4f,
    wow64_ext_glVertexAttrib4fARB,
    wow64_ext_glVertexAttrib4fNV,
    wow64_ext_glVertexAttrib4fv,
    wow64_ext_glVertexAttrib4fvARB,
    wow64_ext_glVertexAttrib4fvNV,
    wow64_ext_glVertexAttrib4hNV,
    wow64_ext_glVertexAttrib4hvNV,
    wow64_ext_glVertexAttrib4iv,
    wow64_ext_glVertexAttrib4ivARB,
    wow64_ext_glVertexAttrib4s,
    wow64_ext_glVertexAttrib4sARB,
    wow64_ext_glVertexAttrib4sNV,
    wow64_ext_glVertexAttrib4sv,
    wow64_ext_glVertexAttrib4svARB,
    wow64_ext_glVertexAttrib4svNV,
    wow64_ext_glVertexAttrib4ubNV,
    wow64_ext_glVertexAttrib4ubv,
    wow64_ext_glVertexAttrib4ubvARB,
    wow64_ext_glVertexAttrib4ubvNV,
    wow64_ext_glVertexAttrib4uiv,
    wow64_ext_glVertexAttrib4uivARB,
    wow64_ext_glVertexAttrib4usv,
    wow64_ext_glVertexAttrib4usvARB,
    wow64_ext_glVertexAttribArrayObjectATI,
    wow64_ext_glVertexAttribBinding,
    wow64_ext_glVertexAttribDivisor,
    wow64_ext_glVertexAttribDivisorARB,
    wow64_ext_glVertexAttribFormat,
    wow64_ext_glVertexAttribFormatNV,
    wow64_ext_glVertexAttribI1i,
    wow64_ext_glVertexAttribI1iEXT,
    wow64_ext_glVertexAttribI1iv,
    wow64_ext_glVertexAttribI1ivEXT,
    wow64_ext_glVertexAttribI1ui,
    wow64_ext_glVertexAttribI1uiEXT,
    wow64_ext_glVertexAttribI1uiv,
    wow64_ext_glVertexAttribI1uivEXT,
    wow64_ext_glVertexAttribI2i,
    wow64_ext_glVertexAttribI2iEXT,
    wow64_ext_glVertexAttribI2iv,
    wow64_ext_glVertexAttribI2ivEXT,
    wow64_ext_glVertexAttribI2ui,
    wow64_ext_glVertexAttribI2uiEXT,
    wow64_ext_glVertexAttribI2uiv,
    wow64_ext_glVertexAttribI2uivEXT,
    wow64_ext_glVertexAttribI3i,
    wow64_ext_glVertexAttribI3iEXT,
    wow64_ext_glVertexAttribI3iv,
    wow64_ext_glVertexAttribI3ivEXT,
    wow64_ext_glVertexAttribI3ui,
    wow64_ext_glVertexAttribI3uiEXT,
    wow64_ext_glVertexAttribI3uiv,
    wow64_ext_glVertexAttribI3uivEXT,
    wow64_ext_glVertexAttribI4bv,
    wow64_ext_glVertexAttribI4bvEXT,
    wow64_ext_glVertexAttribI4i,
    wow64_ext_glVertexAttribI4iEXT,
    wow64_ext_glVertexAttribI4iv,
    wow64_ext_glVertexAttribI4ivEXT,
    wow64_ext_glVertexAttribI4sv,
    wow64_ext_glVertexAttribI4svEXT,
    wow64_ext_glVertexAttribI4ubv,
    wow64_ext_glVertexAttribI4ubvEXT,
    wow64_ext_glVertexAttribI4ui,
    wow64_ext_glVertexAttribI4uiEXT,
    wow64_ext_glVertexAttribI4uiv,
    wow64_ext_glVertexAttribI4uivEXT,
    wow64_ext_glVertexAttribI4usv,
    wow64_ext_glVertexAttribI4usvEXT,
    wow64_ext_glVertexAttribIFormat,
    wow64_ext_glVertexAttribIFormatNV,
    wow64_ext_glVertexAttribIPointer,
    wow64_ext_glVertexAttribIPointerEXT,
    wow64_ext_glVertexAttribL1d,
    wow64_ext_glVertexAttribL1dEXT,
    wow64_ext_glVertexAttribL1dv,
    wow64_ext_glVertexAttribL1dvEXT,
    wow64_ext_glVertexAttribL1i64NV,
    wow64_ext_glVertexAttribL1i64vNV,
    wow64_ext_glVertexAttribL1ui64ARB,
    wow64_ext_glVertexAttribL1ui64NV,
    wow64_ext_glVertexAttribL1ui64vARB,
    wow64_ext_glVertexAttribL1ui64vNV,
    wow64_ext_glVertexAttribL2d,
    wow64_ext_glVertexAttribL2dEXT,
    wow64_ext_glVertexAttribL2dv,
    wow64_ext_glVertexAttribL2dvEXT,
    wow64_ext_glVertexAttribL2i64NV,
    wow64_ext_glVertexAttribL2i64vNV,
    wow64_ext_glVertexAttribL2ui64NV,
    wow64_ext_glVertexAttribL2ui64vNV,
    wow64_ext_glVertexAttribL3d,
    wow64_ext_glVertexAttribL3dEXT,
    wow64_ext_glVertexAttribL3dv,
    wow64_ext_glVertexAttribL3dvEXT,
    wow64_ext_glVertexAttribL3i64NV,
    wow64_ext_glVertexAttribL3i64vNV,
    wow64_ext_glVertexAttribL3ui64NV,
    wow64_ext_glVertexAttribL3ui64vNV,
    wow64_ext_glVertexAttribL4d,
    wow64_ext_glVertexAttribL4dEXT,
    wow64_ext_glVertexAttribL4dv,
    wow64_ext_glVertexAttribL4dvEXT,
    wow64_ext_glVertexAttribL4i64NV,
    wow64_ext_glVertexAttribL4i64vNV,
    wow64_ext_glVertexAttribL4ui64NV,
    wow64_ext_glVertexAttribL4ui64vNV,
    wow64_ext_glVertexAttribLFormat,
    wow64_ext_glVertexAttribLFormatNV,
    wow64_ext_glVertexAttribLPointer,
    wow64_ext_glVertexAttribLPointerEXT,
    wow64_ext_glVertexAttribP1ui,
    wow64_ext_glVertexAttribP1uiv,
    wow64_ext_glVertexAttribP2ui,
    wow64_ext_glVertexAttribP2uiv,
    wow64_ext_glVertexAttribP3ui,
    wow64_ext_glVertexAttribP3uiv,
    wow64_ext_glVertexAttribP4ui,
    wow64_ext_glVertexAttribP4uiv,
    wow64_ext_glVertexAttribParameteriAMD,
    wow64_ext_glVertexAttribPointer,
    wow64_ext_glVertexAttribPointerARB,
    wow64_ext_glVertexAttribPointerNV,
    wow64_ext_glVertexAttribs1dvNV,
    wow64_ext_glVertexAttribs1fvNV,
    wow64_ext_glVertexAttribs1hvNV,
    wow64_ext_glVertexAttribs1svNV,
    wow64_ext_glVertexAttribs2dvNV,
    wow64_ext_glVertexAttribs2fvNV,
    wow64_ext_glVertexAttribs2hvNV,
    wow64_ext_glVertexAttribs2svNV,
    wow64_ext_glVertexAttribs3dvNV,
    wow64_ext_glVertexAttribs3fvNV,
    wow64_ext_glVertexAttribs3hvNV,
    wow64_ext_glVertexAttribs3svNV,
    wow64_ext_glVertexAttribs4dvNV,
    wow64_ext_glVertexAttribs4fvNV,
    wow64_ext_glVertexAttribs4hvNV,
    wow64_ext_glVertexAttribs4svNV,
    wow64_ext_glVertexAttribs4ubvNV,
    wow64_ext_glVertexBindingDivisor,
    wow64_ext_glVertexBlendARB,
    wow64_ext_glVertexBlendEnvfATI,
    wow64_ext_glVertexBlendEnviATI,
    wow64_ext_glVertexFormatNV,
    wow64_ext_glVertexP2ui,
    wow64_ext_glVertexP2uiv,
    wow64_ext_glVertexP3ui,
    wow64_ext_glVertexP3uiv,
    wow64_ext_glVertexP4ui,
    wow64_ext_glVertexP4uiv,
    wow64_ext_glVertexPointerEXT,
    wow64_ext_glVertexPointerListIBM,
    wow64_ext_glVertexPointervINTEL,
    wow64_ext_glVertexStream1dATI,
    wow64_ext_glVertexStream1dvATI,
    wow64_ext_glVertexStream1fATI,
    wow64_ext_glVertexStream1fvATI,
    wow64_ext_glVertexStream1iATI,
    wow64_ext_glVertexStream1ivATI,
    wow64_ext_glVertexStream1sATI,
    wow64_ext_glVertexStream1svATI,
    wow64_ext_glVertexStream2dATI,
    wow64_ext_glVertexStream2dvATI,
    wow64_ext_glVertexStream2fATI,
    wow64_ext_glVertexStream2fvATI,
    wow64_ext_glVertexStream2iATI,
    wow64_ext_glVertexStream2ivATI,
    wow64_ext_glVertexStream2sATI,
    wow64_ext_glVertexStream2svATI,
    wow64_ext_glVertexStream3dATI,
    wow64_ext_glVertexStream3dvATI,
    wow64_ext_glVertexStream3fATI,
    wow64_ext_glVertexStream3fvATI,
    wow64_ext_glVertexStream3iATI,
    wow64_ext_glVertexStream3ivATI,
    wow64_ext_glVertexStream3sATI,
    wow64_ext_glVertexStream3svATI,
    wow64_ext_glVertexStream4dATI,
    wow64_ext_glVertexStream4dvATI,
    wow64_ext_glVertexStream4fATI,
    wow64_ext_glVertexStream4fvATI,
    wow64_ext_glVertexStream4iATI,
    wow64_ext_glVertexStream4ivATI,
    wow64_ext_glVertexStream4sATI,
    wow64_ext_glVertexStream4svATI,
    wow64_ext_glVertexWeightPointerEXT,
    wow64_ext_glVertexWeightfEXT,
    wow64_ext_glVertexWeightfvEXT,
    wow64_ext_glVertexWeighthNV,
    wow64_ext_glVertexWeighthvNV,
    wow64_ext_glVideoCaptureNV,
    wow64_ext_glVideoCaptureStreamParameterdvNV,
    wow64_ext_glVideoCaptureStreamParameterfvNV,
    wow64_ext_glVideoCaptureStreamParameterivNV,
    wow64_ext_glViewportArrayv,
    wow64_ext_glViewportIndexedf,
    wow64_ext_glViewportIndexedfv,
    wow64_ext_glViewportPositionWScaleNV,
    wow64_ext_glViewportSwizzleNV,
    wow64_ext_glWaitSemaphoreEXT,
    wow64_ext_glWaitSemaphoreui64NVX,
    wow64_ext_glWaitSync,
    wow64_ext_glWaitVkSemaphoreNV,
    wow64_ext_glWeightPathsNV,
    wow64_ext_glWeightPointerARB,
    wow64_ext_glWeightbvARB,
    wow64_ext_glWeightdvARB,
    wow64_ext_glWeightfvARB,
    wow64_ext_glWeightivARB,
    wow64_ext_glWeightsvARB,
    wow64_ext_glWeightubvARB,
    wow64_ext_glWeightuivARB,
    wow64_ext_glWeightusvARB,
    wow64_ext_glWindowPos2d,
    wow64_ext_glWindowPos2dARB,
    wow64_ext_glWindowPos2dMESA,
    wow64_ext_glWindowPos2dv,
    wow64_ext_glWindowPos2dvARB,
    wow64_ext_glWindowPos2dvMESA,
    wow64_ext_glWindowPos2f,
    wow64_ext_glWindowPos2fARB,
    wow64_ext_glWindowPos2fMESA,
    wow64_ext_glWindowPos2fv,
    wow64_ext_glWindowPos2fvARB,
    wow64_ext_glWindowPos2fvMESA,
    wow64_ext_glWindowPos2i,
    wow64_ext_glWindowPos2iARB,
    wow64_ext_glWindowPos2iMESA,
    wow64_ext_glWindowPos2iv,
    wow64_ext_glWindowPos2ivARB,
    wow64_ext_glWindowPos2ivMESA,
    wow64_ext_glWindowPos2s,
    wow64_ext_glWindowPos2sARB,
    wow64_ext_glWindowPos2sMESA,
    wow64_ext_glWindowPos2sv,
    wow64_ext_glWindowPos2svARB,
    wow64_ext_glWindowPos2svMESA,
    wow64_ext_glWindowPos3d,
    wow64_ext_glWindowPos3dARB,
    wow64_ext_glWindowPos3dMESA,
    wow64_ext_glWindowPos3dv,
    wow64_ext_glWindowPos3dvARB,
    wow64_ext_glWindowPos3dvMESA,
    wow64_ext_glWindowPos3f,
    wow64_ext_glWindowPos3fARB,
    wow64_ext_glWindowPos3fMESA,
    wow64_ext_glWindowPos3fv,
    wow64_ext_glWindowPos3fvARB,
    wow64_ext_glWindowPos3fvMESA,
    wow64_ext_glWindowPos3i,
    wow64_ext_glWindowPos3iARB,
    wow64_ext_glWindowPos3iMESA,
    wow64_ext_glWindowPos3iv,
    wow64_ext_glWindowPos3ivARB,
    wow64_ext_glWindowPos3ivMESA,
    wow64_ext_glWindowPos3s,
    wow64_ext_glWindowPos3sARB,
    wow64_ext_glWindowPos3sMESA,
    wow64_ext_glWindowPos3sv,
    wow64_ext_glWindowPos3svARB,
    wow64_ext_glWindowPos3svMESA,
    wow64_ext_glWindowPos4dMESA,
    wow64_ext_glWindowPos4dvMESA,
    wow64_ext_glWindowPos4fMESA,
    wow64_ext_glWindowPos4fvMESA,
    wow64_ext_glWindowPos4iMESA,
    wow64_ext_glWindowPos4ivMESA,
    wow64_ext_glWindowPos4sMESA,
    wow64_ext_glWindowPos4svMESA,
    wow64_ext_glWindowRectanglesEXT,
    wow64_ext_glWriteMaskEXT,
    wow64_ext_wglAllocateMemoryNV,
    wow64_ext_wglBindTexImageARB,
    wow64_ext_wglCreateContextAttribsARB,
    wow64_ext_wglCreatePbufferARB,
    wow64_ext_wglDestroyPbufferARB,
    wow64_ext_wglFreeMemoryNV,
    wow64_ext_wglGetPbufferDCARB,
    wow64_ext_wglGetSwapIntervalEXT,
    wow64_ext_wglMakeContextCurrentARB,
    wow64_ext_wglQueryCurrentRendererIntegerWINE,
    wow64_ext_wglQueryCurrentRendererStringWINE,
    wow64_ext_wglQueryPbufferARB,
    wow64_ext_wglQueryRendererIntegerWINE,
    wow64_ext_wglQueryRendererStringWINE,
    wow64_ext_wglReleasePbufferDCARB,
    wow64_ext_wglReleaseTexImageARB,
    wow64_ext_wglSetPbufferAttribARB,
    wow64_ext_wglSetPixelFormatWINE,
    wow64_ext_wglSwapIntervalEXT,
};

C_ASSERT(ARRAYSIZE(__wine_unix_call_wow64_funcs) == funcs_count);

#endif

static int null_wglGetPixelFormat( HDC hdc )
{
    WARN( "unsupported\n" );
    RtlSetLastWin32Error( ERROR_INVALID_PIXEL_FORMAT );
    return 0;
}
static BOOL null_wglSetPixelFormat( HDC hdc, int ipfd, const PIXELFORMATDESCRIPTOR *ppfd )
{
    WARN( "unsupported\n" );
    return 0;
}
static void null_glAccum( GLenum op, GLfloat value )
{
    WARN( "unsupported\n" );
}
static void null_glAlphaFunc( GLenum func, GLfloat ref )
{
    WARN( "unsupported\n" );
}
static GLboolean null_glAreTexturesResident( GLsizei n, const GLuint *textures, GLboolean *residences )
{
    WARN( "unsupported\n" );
    return 0;
}
static void null_glArrayElement( GLint i )
{
    WARN( "unsupported\n" );
}
static void null_glBegin( GLenum mode )
{
    WARN( "unsupported\n" );
}
static void null_glBindTexture( GLenum target, GLuint texture )
{
    WARN( "unsupported\n" );
}
static void null_glBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap )
{
    WARN( "unsupported\n" );
}
static void null_glBlendFunc( GLenum sfactor, GLenum dfactor )
{
    WARN( "unsupported\n" );
}
static void null_glCallList( GLuint list )
{
    WARN( "unsupported\n" );
}
static void null_glCallLists( GLsizei n, GLenum type, const void *lists )
{
    WARN( "unsupported\n" );
}
static void null_glClear( GLbitfield mask )
{
    WARN( "unsupported\n" );
}
static void null_glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
{
    WARN( "unsupported\n" );
}
static void null_glClearColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
{
    WARN( "unsupported\n" );
}
static void null_glClearDepth( GLdouble depth )
{
    WARN( "unsupported\n" );
}
static void null_glClearIndex( GLfloat c )
{
    WARN( "unsupported\n" );
}
static void null_glClearStencil( GLint s )
{
    WARN( "unsupported\n" );
}
static void null_glClipPlane( GLenum plane, const GLdouble *equation )
{
    WARN( "unsupported\n" );
}
static void null_glColor3b( GLbyte red, GLbyte green, GLbyte blue )
{
    WARN( "unsupported\n" );
}
static void null_glColor3bv( const GLbyte *v )
{
    WARN( "unsupported\n" );
}
static void null_glColor3d( GLdouble red, GLdouble green, GLdouble blue )
{
    WARN( "unsupported\n" );
}
static void null_glColor3dv( const GLdouble *v )
{
    WARN( "unsupported\n" );
}
static void null_glColor3f( GLfloat red, GLfloat green, GLfloat blue )
{
    WARN( "unsupported\n" );
}
static void null_glColor3fv( const GLfloat *v )
{
    WARN( "unsupported\n" );
}
static void null_glColor3i( GLint red, GLint green, GLint blue )
{
    WARN( "unsupported\n" );
}
static void null_glColor3iv( const GLint *v )
{
    WARN( "unsupported\n" );
}
static void null_glColor3s( GLshort red, GLshort green, GLshort blue )
{
    WARN( "unsupported\n" );
}
static void null_glColor3sv( const GLshort *v )
{
    WARN( "unsupported\n" );
}
static void null_glColor3ub( GLubyte red, GLubyte green, GLubyte blue )
{
    WARN( "unsupported\n" );
}
static void null_glColor3ubv( const GLubyte *v )
{
    WARN( "unsupported\n" );
}
static void null_glColor3ui( GLuint red, GLuint green, GLuint blue )
{
    WARN( "unsupported\n" );
}
static void null_glColor3uiv( const GLuint *v )
{
    WARN( "unsupported\n" );
}
static void null_glColor3us( GLushort red, GLushort green, GLushort blue )
{
    WARN( "unsupported\n" );
}
static void null_glColor3usv( const GLushort *v )
{
    WARN( "unsupported\n" );
}
static void null_glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
{
    WARN( "unsupported\n" );
}
static void null_glColor4bv( const GLbyte *v )
{
    WARN( "unsupported\n" );
}
static void null_glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
{
    WARN( "unsupported\n" );
}
static void null_glColor4dv( const GLdouble *v )
{
    WARN( "unsupported\n" );
}
static void null_glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
{
    WARN( "unsupported\n" );
}
static void null_glColor4fv( const GLfloat *v )
{
    WARN( "unsupported\n" );
}
static void null_glColor4i( GLint red, GLint green, GLint blue, GLint alpha )
{
    WARN( "unsupported\n" );
}
static void null_glColor4iv( const GLint *v )
{
    WARN( "unsupported\n" );
}
static void null_glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha )
{
    WARN( "unsupported\n" );
}
static void null_glColor4sv( const GLshort *v )
{
    WARN( "unsupported\n" );
}
static void null_glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
{
    WARN( "unsupported\n" );
}
static void null_glColor4ubv( const GLubyte *v )
{
    WARN( "unsupported\n" );
}
static void null_glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
{
    WARN( "unsupported\n" );
}
static void null_glColor4uiv( const GLuint *v )
{
    WARN( "unsupported\n" );
}
static void null_glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha )
{
    WARN( "unsupported\n" );
}
static void null_glColor4usv( const GLushort *v )
{
    WARN( "unsupported\n" );
}
static void null_glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
{
    WARN( "unsupported\n" );
}
static void null_glColorMaterial( GLenum face, GLenum mode )
{
    WARN( "unsupported\n" );
}
static void null_glColorPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
{
    WARN( "unsupported\n" );
}
static void null_glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type )
{
    WARN( "unsupported\n" );
}
static void null_glCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border )
{
    WARN( "unsupported\n" );
}
static void null_glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
{
    WARN( "unsupported\n" );
}
static void null_glCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
{
    WARN( "unsupported\n" );
}
static void null_glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
{
    WARN( "unsupported\n" );
}
static void null_glCullFace( GLenum mode )
{
    WARN( "unsupported\n" );
}
static void null_glDeleteLists( GLuint list, GLsizei range )
{
    WARN( "unsupported\n" );
}
static void null_glDeleteTextures( GLsizei n, const GLuint *textures )
{
    WARN( "unsupported\n" );
}
static void null_glDepthFunc( GLenum func )
{
    WARN( "unsupported\n" );
}
static void null_glDepthMask( GLboolean flag )
{
    WARN( "unsupported\n" );
}
static void null_glDepthRange( GLdouble n, GLdouble f )
{
    WARN( "unsupported\n" );
}
static void null_glDisable( GLenum cap )
{
    WARN( "unsupported\n" );
}
static void null_glDisableClientState( GLenum array )
{
    WARN( "unsupported\n" );
}
static void null_glDrawArrays( GLenum mode, GLint first, GLsizei count )
{
    WARN( "unsupported\n" );
}
static void null_glDrawBuffer( GLenum buf )
{
    WARN( "unsupported\n" );
}
static void null_glDrawElements( GLenum mode, GLsizei count, GLenum type, const void *indices )
{
    WARN( "unsupported\n" );
}
static void null_glDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
{
    WARN( "unsupported\n" );
}
static void null_glEdgeFlag( GLboolean flag )
{
    WARN( "unsupported\n" );
}
static void null_glEdgeFlagPointer( GLsizei stride, const void *pointer )
{
    WARN( "unsupported\n" );
}
static void null_glEdgeFlagv( const GLboolean *flag )
{
    WARN( "unsupported\n" );
}
static void null_glEnable( GLenum cap )
{
    WARN( "unsupported\n" );
}
static void null_glEnableClientState( GLenum array )
{
    WARN( "unsupported\n" );
}
static void null_glEnd(void)
{
    WARN( "unsupported\n" );
}
static void null_glEndList(void)
{
    WARN( "unsupported\n" );
}
static void null_glEvalCoord1d( GLdouble u )
{
    WARN( "unsupported\n" );
}
static void null_glEvalCoord1dv( const GLdouble *u )
{
    WARN( "unsupported\n" );
}
static void null_glEvalCoord1f( GLfloat u )
{
    WARN( "unsupported\n" );
}
static void null_glEvalCoord1fv( const GLfloat *u )
{
    WARN( "unsupported\n" );
}
static void null_glEvalCoord2d( GLdouble u, GLdouble v )
{
    WARN( "unsupported\n" );
}
static void null_glEvalCoord2dv( const GLdouble *u )
{
    WARN( "unsupported\n" );
}
static void null_glEvalCoord2f( GLfloat u, GLfloat v )
{
    WARN( "unsupported\n" );
}
static void null_glEvalCoord2fv( const GLfloat *u )
{
    WARN( "unsupported\n" );
}
static void null_glEvalMesh1( GLenum mode, GLint i1, GLint i2 )
{
    WARN( "unsupported\n" );
}
static void null_glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
{
    WARN( "unsupported\n" );
}
static void null_glEvalPoint1( GLint i )
{
    WARN( "unsupported\n" );
}
static void null_glEvalPoint2( GLint i, GLint j )
{
    WARN( "unsupported\n" );
}
static void null_glFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
{
    WARN( "unsupported\n" );
}
static void null_glFinish(void)
{
    WARN( "unsupported\n" );
}
static void null_glFlush(void)
{
    WARN( "unsupported\n" );
}
static void null_glFogf( GLenum pname, GLfloat param )
{
    WARN( "unsupported\n" );
}
static void null_glFogfv( GLenum pname, const GLfloat *params )
{
    WARN( "unsupported\n" );
}
static void null_glFogi( GLenum pname, GLint param )
{
    WARN( "unsupported\n" );
}
static void null_glFogiv( GLenum pname, const GLint *params )
{
    WARN( "unsupported\n" );
}
static void null_glFrontFace( GLenum mode )
{
    WARN( "unsupported\n" );
}
static void null_glFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
{
    WARN( "unsupported\n" );
}
static GLuint null_glGenLists( GLsizei range )
{
    WARN( "unsupported\n" );
    return 0;
}
static void null_glGenTextures( GLsizei n, GLuint *textures )
{
    WARN( "unsupported\n" );
}
static void null_glGetBooleanv( GLenum pname, GLboolean *data )
{
    WARN( "unsupported\n" );
}
static void null_glGetClipPlane( GLenum plane, GLdouble *equation )
{
    WARN( "unsupported\n" );
}
static void null_glGetDoublev( GLenum pname, GLdouble *data )
{
    WARN( "unsupported\n" );
}
static GLenum null_glGetError(void)
{
    WARN( "unsupported\n" );
    return GL_INVALID_OPERATION;
}
static void null_glGetFloatv( GLenum pname, GLfloat *data )
{
    WARN( "unsupported\n" );
}
static void null_glGetIntegerv( GLenum pname, GLint *data )
{
    WARN( "unsupported\n" );
}
static void null_glGetLightfv( GLenum light, GLenum pname, GLfloat *params )
{
    WARN( "unsupported\n" );
}
static void null_glGetLightiv( GLenum light, GLenum pname, GLint *params )
{
    WARN( "unsupported\n" );
}
static void null_glGetMapdv( GLenum target, GLenum query, GLdouble *v )
{
    WARN( "unsupported\n" );
}
static void null_glGetMapfv( GLenum target, GLenum query, GLfloat *v )
{
    WARN( "unsupported\n" );
}
static void null_glGetMapiv( GLenum target, GLenum query, GLint *v )
{
    WARN( "unsupported\n" );
}
static void null_glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
{
    WARN( "unsupported\n" );
}
static void null_glGetMaterialiv( GLenum face, GLenum pname, GLint *params )
{
    WARN( "unsupported\n" );
}
static void null_glGetPixelMapfv( GLenum map, GLfloat *values )
{
    WARN( "unsupported\n" );
}
static void null_glGetPixelMapuiv( GLenum map, GLuint *values )
{
    WARN( "unsupported\n" );
}
static void null_glGetPixelMapusv( GLenum map, GLushort *values )
{
    WARN( "unsupported\n" );
}
static void null_glGetPointerv( GLenum pname, void **params )
{
    WARN( "unsupported\n" );
}
static void null_glGetPolygonStipple( GLubyte *mask )
{
    WARN( "unsupported\n" );
}
static const GLubyte * null_glGetString( GLenum name )
{
    WARN( "unsupported\n" );
    return 0;
}
static void null_glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
{
    WARN( "unsupported\n" );
}
static void null_glGetTexEnviv( GLenum target, GLenum pname, GLint *params )
{
    WARN( "unsupported\n" );
}
static void null_glGetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
{
    WARN( "unsupported\n" );
}
static void null_glGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
{
    WARN( "unsupported\n" );
}
static void null_glGetTexGeniv( GLenum coord, GLenum pname, GLint *params )
{
    WARN( "unsupported\n" );
}
static void null_glGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, void *pixels )
{
    WARN( "unsupported\n" );
}
static void null_glGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat *params )
{
    WARN( "unsupported\n" );
}
static void null_glGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params )
{
    WARN( "unsupported\n" );
}
static void null_glGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
{
    WARN( "unsupported\n" );
}
static void null_glGetTexParameteriv( GLenum target, GLenum pname, GLint *params )
{
    WARN( "unsupported\n" );
}
static void null_glHint( GLenum target, GLenum mode )
{
    WARN( "unsupported\n" );
}
static void null_glIndexMask( GLuint mask )
{
    WARN( "unsupported\n" );
}
static void null_glIndexPointer( GLenum type, GLsizei stride, const void *pointer )
{
    WARN( "unsupported\n" );
}
static void null_glIndexd( GLdouble c )
{
    WARN( "unsupported\n" );
}
static void null_glIndexdv( const GLdouble *c )
{
    WARN( "unsupported\n" );
}
static void null_glIndexf( GLfloat c )
{
    WARN( "unsupported\n" );
}
static void null_glIndexfv( const GLfloat *c )
{
    WARN( "unsupported\n" );
}
static void null_glIndexi( GLint c )
{
    WARN( "unsupported\n" );
}
static void null_glIndexiv( const GLint *c )
{
    WARN( "unsupported\n" );
}
static void null_glIndexs( GLshort c )
{
    WARN( "unsupported\n" );
}
static void null_glIndexsv( const GLshort *c )
{
    WARN( "unsupported\n" );
}
static void null_glIndexub( GLubyte c )
{
    WARN( "unsupported\n" );
}
static void null_glIndexubv( const GLubyte *c )
{
    WARN( "unsupported\n" );
}
static void null_glInitNames(void)
{
    WARN( "unsupported\n" );
}
static void null_glInterleavedArrays( GLenum format, GLsizei stride, const void *pointer )
{
    WARN( "unsupported\n" );
}
static GLboolean null_glIsEnabled( GLenum cap )
{
    WARN( "unsupported\n" );
    return 0;
}
static GLboolean null_glIsList( GLuint list )
{
    WARN( "unsupported\n" );
    return 0;
}
static GLboolean null_glIsTexture( GLuint texture )
{
    WARN( "unsupported\n" );
    return 0;
}
static void null_glLightModelf( GLenum pname, GLfloat param )
{
    WARN( "unsupported\n" );
}
static void null_glLightModelfv( GLenum pname, const GLfloat *params )
{
    WARN( "unsupported\n" );
}
static void null_glLightModeli( GLenum pname, GLint param )
{
    WARN( "unsupported\n" );
}
static void null_glLightModeliv( GLenum pname, const GLint *params )
{
    WARN( "unsupported\n" );
}
static void null_glLightf( GLenum light, GLenum pname, GLfloat param )
{
    WARN( "unsupported\n" );
}
static void null_glLightfv( GLenum light, GLenum pname, const GLfloat *params )
{
    WARN( "unsupported\n" );
}
static void null_glLighti( GLenum light, GLenum pname, GLint param )
{
    WARN( "unsupported\n" );
}
static void null_glLightiv( GLenum light, GLenum pname, const GLint *params )
{
    WARN( "unsupported\n" );
}
static void null_glLineStipple( GLint factor, GLushort pattern )
{
    WARN( "unsupported\n" );
}
static void null_glLineWidth( GLfloat width )
{
    WARN( "unsupported\n" );
}
static void null_glListBase( GLuint base )
{
    WARN( "unsupported\n" );
}
static void null_glLoadIdentity(void)
{
    WARN( "unsupported\n" );
}
static void null_glLoadMatrixd( const GLdouble *m )
{
    WARN( "unsupported\n" );
}
static void null_glLoadMatrixf( const GLfloat *m )
{
    WARN( "unsupported\n" );
}
static void null_glLoadName( GLuint name )
{
    WARN( "unsupported\n" );
}
static void null_glLogicOp( GLenum opcode )
{
    WARN( "unsupported\n" );
}
static void null_glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points )
{
    WARN( "unsupported\n" );
}
static void null_glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points )
{
    WARN( "unsupported\n" );
}
static void null_glMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points )
{
    WARN( "unsupported\n" );
}
static void null_glMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points )
{
    WARN( "unsupported\n" );
}
static void null_glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
{
    WARN( "unsupported\n" );
}
static void null_glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
{
    WARN( "unsupported\n" );
}
static void null_glMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 )
{
    WARN( "unsupported\n" );
}
static void null_glMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 )
{
    WARN( "unsupported\n" );
}
static void null_glMaterialf( GLenum face, GLenum pname, GLfloat param )
{
    WARN( "unsupported\n" );
}
static void null_glMaterialfv( GLenum face, GLenum pname, const GLfloat *params )
{
    WARN( "unsupported\n" );
}
static void null_glMateriali( GLenum face, GLenum pname, GLint param )
{
    WARN( "unsupported\n" );
}
static void null_glMaterialiv( GLenum face, GLenum pname, const GLint *params )
{
    WARN( "unsupported\n" );
}
static void null_glMatrixMode( GLenum mode )
{
    WARN( "unsupported\n" );
}
static void null_glMultMatrixd( const GLdouble *m )
{
    WARN( "unsupported\n" );
}
static void null_glMultMatrixf( const GLfloat *m )
{
    WARN( "unsupported\n" );
}
static void null_glNewList( GLuint list, GLenum mode )
{
    WARN( "unsupported\n" );
}
static void null_glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz )
{
    WARN( "unsupported\n" );
}
static void null_glNormal3bv( const GLbyte *v )
{
    WARN( "unsupported\n" );
}
static void null_glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz )
{
    WARN( "unsupported\n" );
}
static void null_glNormal3dv( const GLdouble *v )
{
    WARN( "unsupported\n" );
}
static void null_glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz )
{
    WARN( "unsupported\n" );
}
static void null_glNormal3fv( const GLfloat *v )
{
    WARN( "unsupported\n" );
}
static void null_glNormal3i( GLint nx, GLint ny, GLint nz )
{
    WARN( "unsupported\n" );
}
static void null_glNormal3iv( const GLint *v )
{
    WARN( "unsupported\n" );
}
static void null_glNormal3s( GLshort nx, GLshort ny, GLshort nz )
{
    WARN( "unsupported\n" );
}
static void null_glNormal3sv( const GLshort *v )
{
    WARN( "unsupported\n" );
}
static void null_glNormalPointer( GLenum type, GLsizei stride, const void *pointer )
{
    WARN( "unsupported\n" );
}
static void null_glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
{
    WARN( "unsupported\n" );
}
static void null_glPassThrough( GLfloat token )
{
    WARN( "unsupported\n" );
}
static void null_glPixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
{
    WARN( "unsupported\n" );
}
static void null_glPixelMapuiv( GLenum map, GLsizei mapsize, const GLuint *values )
{
    WARN( "unsupported\n" );
}
static void null_glPixelMapusv( GLenum map, GLsizei mapsize, const GLushort *values )
{
    WARN( "unsupported\n" );
}
static void null_glPixelStoref( GLenum pname, GLfloat param )
{
    WARN( "unsupported\n" );
}
static void null_glPixelStorei( GLenum pname, GLint param )
{
    WARN( "unsupported\n" );
}
static void null_glPixelTransferf( GLenum pname, GLfloat param )
{
    WARN( "unsupported\n" );
}
static void null_glPixelTransferi( GLenum pname, GLint param )
{
    WARN( "unsupported\n" );
}
static void null_glPixelZoom( GLfloat xfactor, GLfloat yfactor )
{
    WARN( "unsupported\n" );
}
static void null_glPointSize( GLfloat size )
{
    WARN( "unsupported\n" );
}
static void null_glPolygonMode( GLenum face, GLenum mode )
{
    WARN( "unsupported\n" );
}
static void null_glPolygonOffset( GLfloat factor, GLfloat units )
{
    WARN( "unsupported\n" );
}
static void null_glPolygonStipple( const GLubyte *mask )
{
    WARN( "unsupported\n" );
}
static void null_glPopAttrib(void)
{
    WARN( "unsupported\n" );
}
static void null_glPopClientAttrib(void)
{
    WARN( "unsupported\n" );
}
static void null_glPopMatrix(void)
{
    WARN( "unsupported\n" );
}
static void null_glPopName(void)
{
    WARN( "unsupported\n" );
}
static void null_glPrioritizeTextures( GLsizei n, const GLuint *textures, const GLfloat *priorities )
{
    WARN( "unsupported\n" );
}
static void null_glPushAttrib( GLbitfield mask )
{
    WARN( "unsupported\n" );
}
static void null_glPushClientAttrib( GLbitfield mask )
{
    WARN( "unsupported\n" );
}
static void null_glPushMatrix(void)
{
    WARN( "unsupported\n" );
}
static void null_glPushName( GLuint name )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos2d( GLdouble x, GLdouble y )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos2dv( const GLdouble *v )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos2f( GLfloat x, GLfloat y )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos2fv( const GLfloat *v )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos2i( GLint x, GLint y )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos2iv( const GLint *v )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos2s( GLshort x, GLshort y )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos2sv( const GLshort *v )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos3d( GLdouble x, GLdouble y, GLdouble z )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos3dv( const GLdouble *v )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos3f( GLfloat x, GLfloat y, GLfloat z )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos3fv( const GLfloat *v )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos3i( GLint x, GLint y, GLint z )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos3iv( const GLint *v )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos3s( GLshort x, GLshort y, GLshort z )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos3sv( const GLshort *v )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos4dv( const GLdouble *v )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos4fv( const GLfloat *v )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos4i( GLint x, GLint y, GLint z, GLint w )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos4iv( const GLint *v )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w )
{
    WARN( "unsupported\n" );
}
static void null_glRasterPos4sv( const GLshort *v )
{
    WARN( "unsupported\n" );
}
static void null_glReadBuffer( GLenum src )
{
    WARN( "unsupported\n" );
}
static void null_glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels )
{
    WARN( "unsupported\n" );
}
static void null_glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 )
{
    WARN( "unsupported\n" );
}
static void null_glRectdv( const GLdouble *v1, const GLdouble *v2 )
{
    WARN( "unsupported\n" );
}
static void null_glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
{
    WARN( "unsupported\n" );
}
static void null_glRectfv( const GLfloat *v1, const GLfloat *v2 )
{
    WARN( "unsupported\n" );
}
static void null_glRecti( GLint x1, GLint y1, GLint x2, GLint y2 )
{
    WARN( "unsupported\n" );
}
static void null_glRectiv( const GLint *v1, const GLint *v2 )
{
    WARN( "unsupported\n" );
}
static void null_glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 )
{
    WARN( "unsupported\n" );
}
static void null_glRectsv( const GLshort *v1, const GLshort *v2 )
{
    WARN( "unsupported\n" );
}
static GLint null_glRenderMode( GLenum mode )
{
    WARN( "unsupported\n" );
    return 0;
}
static void null_glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
{
    WARN( "unsupported\n" );
}
static void null_glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
{
    WARN( "unsupported\n" );
}
static void null_glScaled( GLdouble x, GLdouble y, GLdouble z )
{
    WARN( "unsupported\n" );
}
static void null_glScalef( GLfloat x, GLfloat y, GLfloat z )
{
    WARN( "unsupported\n" );
}
static void null_glScissor( GLint x, GLint y, GLsizei width, GLsizei height )
{
    WARN( "unsupported\n" );
}
static void null_glSelectBuffer( GLsizei size, GLuint *buffer )
{
    WARN( "unsupported\n" );
}
static void null_glShadeModel( GLenum mode )
{
    WARN( "unsupported\n" );
}
static void null_glStencilFunc( GLenum func, GLint ref, GLuint mask )
{
    WARN( "unsupported\n" );
}
static void null_glStencilMask( GLuint mask )
{
    WARN( "unsupported\n" );
}
static void null_glStencilOp( GLenum fail, GLenum zfail, GLenum zpass )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord1d( GLdouble s )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord1dv( const GLdouble *v )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord1f( GLfloat s )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord1fv( const GLfloat *v )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord1i( GLint s )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord1iv( const GLint *v )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord1s( GLshort s )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord1sv( const GLshort *v )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord2d( GLdouble s, GLdouble t )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord2dv( const GLdouble *v )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord2f( GLfloat s, GLfloat t )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord2fv( const GLfloat *v )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord2i( GLint s, GLint t )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord2iv( const GLint *v )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord2s( GLshort s, GLshort t )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord2sv( const GLshort *v )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord3d( GLdouble s, GLdouble t, GLdouble r )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord3dv( const GLdouble *v )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord3f( GLfloat s, GLfloat t, GLfloat r )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord3fv( const GLfloat *v )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord3i( GLint s, GLint t, GLint r )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord3iv( const GLint *v )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord3s( GLshort s, GLshort t, GLshort r )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord3sv( const GLshort *v )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord4dv( const GLdouble *v )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord4fv( const GLfloat *v )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord4i( GLint s, GLint t, GLint r, GLint q )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord4iv( const GLint *v )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoord4sv( const GLshort *v )
{
    WARN( "unsupported\n" );
}
static void null_glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
{
    WARN( "unsupported\n" );
}
static void null_glTexEnvf( GLenum target, GLenum pname, GLfloat param )
{
    WARN( "unsupported\n" );
}
static void null_glTexEnvfv( GLenum target, GLenum pname, const GLfloat *params )
{
    WARN( "unsupported\n" );
}
static void null_glTexEnvi( GLenum target, GLenum pname, GLint param )
{
    WARN( "unsupported\n" );
}
static void null_glTexEnviv( GLenum target, GLenum pname, const GLint *params )
{
    WARN( "unsupported\n" );
}
static void null_glTexGend( GLenum coord, GLenum pname, GLdouble param )
{
    WARN( "unsupported\n" );
}
static void null_glTexGendv( GLenum coord, GLenum pname, const GLdouble *params )
{
    WARN( "unsupported\n" );
}
static void null_glTexGenf( GLenum coord, GLenum pname, GLfloat param )
{
    WARN( "unsupported\n" );
}
static void null_glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
{
    WARN( "unsupported\n" );
}
static void null_glTexGeni( GLenum coord, GLenum pname, GLint param )
{
    WARN( "unsupported\n" );
}
static void null_glTexGeniv( GLenum coord, GLenum pname, const GLint *params )
{
    WARN( "unsupported\n" );
}
static void null_glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels )
{
    WARN( "unsupported\n" );
}
static void null_glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels )
{
    WARN( "unsupported\n" );
}
static void null_glTexParameterf( GLenum target, GLenum pname, GLfloat param )
{
    WARN( "unsupported\n" );
}
static void null_glTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
{
    WARN( "unsupported\n" );
}
static void null_glTexParameteri( GLenum target, GLenum pname, GLint param )
{
    WARN( "unsupported\n" );
}
static void null_glTexParameteriv( GLenum target, GLenum pname, const GLint *params )
{
    WARN( "unsupported\n" );
}
static void null_glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels )
{
    WARN( "unsupported\n" );
}
static void null_glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
{
    WARN( "unsupported\n" );
}
static void null_glTranslated( GLdouble x, GLdouble y, GLdouble z )
{
    WARN( "unsupported\n" );
}
static void null_glTranslatef( GLfloat x, GLfloat y, GLfloat z )
{
    WARN( "unsupported\n" );
}
static void null_glVertex2d( GLdouble x, GLdouble y )
{
    WARN( "unsupported\n" );
}
static void null_glVertex2dv( const GLdouble *v )
{
    WARN( "unsupported\n" );
}
static void null_glVertex2f( GLfloat x, GLfloat y )
{
    WARN( "unsupported\n" );
}
static void null_glVertex2fv( const GLfloat *v )
{
    WARN( "unsupported\n" );
}
static void null_glVertex2i( GLint x, GLint y )
{
    WARN( "unsupported\n" );
}
static void null_glVertex2iv( const GLint *v )
{
    WARN( "unsupported\n" );
}
static void null_glVertex2s( GLshort x, GLshort y )
{
    WARN( "unsupported\n" );
}
static void null_glVertex2sv( const GLshort *v )
{
    WARN( "unsupported\n" );
}
static void null_glVertex3d( GLdouble x, GLdouble y, GLdouble z )
{
    WARN( "unsupported\n" );
}
static void null_glVertex3dv( const GLdouble *v )
{
    WARN( "unsupported\n" );
}
static void null_glVertex3f( GLfloat x, GLfloat y, GLfloat z )
{
    WARN( "unsupported\n" );
}
static void null_glVertex3fv( const GLfloat *v )
{
    WARN( "unsupported\n" );
}
static void null_glVertex3i( GLint x, GLint y, GLint z )
{
    WARN( "unsupported\n" );
}
static void null_glVertex3iv( const GLint *v )
{
    WARN( "unsupported\n" );
}
static void null_glVertex3s( GLshort x, GLshort y, GLshort z )
{
    WARN( "unsupported\n" );
}
static void null_glVertex3sv( const GLshort *v )
{
    WARN( "unsupported\n" );
}
static void null_glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    WARN( "unsupported\n" );
}
static void null_glVertex4dv( const GLdouble *v )
{
    WARN( "unsupported\n" );
}
static void null_glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    WARN( "unsupported\n" );
}
static void null_glVertex4fv( const GLfloat *v )
{
    WARN( "unsupported\n" );
}
static void null_glVertex4i( GLint x, GLint y, GLint z, GLint w )
{
    WARN( "unsupported\n" );
}
static void null_glVertex4iv( const GLint *v )
{
    WARN( "unsupported\n" );
}
static void null_glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w )
{
    WARN( "unsupported\n" );
}
static void null_glVertex4sv( const GLshort *v )
{
    WARN( "unsupported\n" );
}
static void null_glVertexPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
{
    WARN( "unsupported\n" );
}
static void null_glViewport( GLint x, GLint y, GLsizei width, GLsizei height )
{
    WARN( "unsupported\n" );
}

struct opengl_funcs null_opengl_funcs =
{
    .p_wglGetPixelFormat = null_wglGetPixelFormat,
    .p_wglSetPixelFormat = null_wglSetPixelFormat,
    .p_glAccum = null_glAccum,
    .p_glAlphaFunc = null_glAlphaFunc,
    .p_glAreTexturesResident = null_glAreTexturesResident,
    .p_glArrayElement = null_glArrayElement,
    .p_glBegin = null_glBegin,
    .p_glBindTexture = null_glBindTexture,
    .p_glBitmap = null_glBitmap,
    .p_glBlendFunc = null_glBlendFunc,
    .p_glCallList = null_glCallList,
    .p_glCallLists = null_glCallLists,
    .p_glClear = null_glClear,
    .p_glClearAccum = null_glClearAccum,
    .p_glClearColor = null_glClearColor,
    .p_glClearDepth = null_glClearDepth,
    .p_glClearIndex = null_glClearIndex,
    .p_glClearStencil = null_glClearStencil,
    .p_glClipPlane = null_glClipPlane,
    .p_glColor3b = null_glColor3b,
    .p_glColor3bv = null_glColor3bv,
    .p_glColor3d = null_glColor3d,
    .p_glColor3dv = null_glColor3dv,
    .p_glColor3f = null_glColor3f,
    .p_glColor3fv = null_glColor3fv,
    .p_glColor3i = null_glColor3i,
    .p_glColor3iv = null_glColor3iv,
    .p_glColor3s = null_glColor3s,
    .p_glColor3sv = null_glColor3sv,
    .p_glColor3ub = null_glColor3ub,
    .p_glColor3ubv = null_glColor3ubv,
    .p_glColor3ui = null_glColor3ui,
    .p_glColor3uiv = null_glColor3uiv,
    .p_glColor3us = null_glColor3us,
    .p_glColor3usv = null_glColor3usv,
    .p_glColor4b = null_glColor4b,
    .p_glColor4bv = null_glColor4bv,
    .p_glColor4d = null_glColor4d,
    .p_glColor4dv = null_glColor4dv,
    .p_glColor4f = null_glColor4f,
    .p_glColor4fv = null_glColor4fv,
    .p_glColor4i = null_glColor4i,
    .p_glColor4iv = null_glColor4iv,
    .p_glColor4s = null_glColor4s,
    .p_glColor4sv = null_glColor4sv,
    .p_glColor4ub = null_glColor4ub,
    .p_glColor4ubv = null_glColor4ubv,
    .p_glColor4ui = null_glColor4ui,
    .p_glColor4uiv = null_glColor4uiv,
    .p_glColor4us = null_glColor4us,
    .p_glColor4usv = null_glColor4usv,
    .p_glColorMask = null_glColorMask,
    .p_glColorMaterial = null_glColorMaterial,
    .p_glColorPointer = null_glColorPointer,
    .p_glCopyPixels = null_glCopyPixels,
    .p_glCopyTexImage1D = null_glCopyTexImage1D,
    .p_glCopyTexImage2D = null_glCopyTexImage2D,
    .p_glCopyTexSubImage1D = null_glCopyTexSubImage1D,
    .p_glCopyTexSubImage2D = null_glCopyTexSubImage2D,
    .p_glCullFace = null_glCullFace,
    .p_glDeleteLists = null_glDeleteLists,
    .p_glDeleteTextures = null_glDeleteTextures,
    .p_glDepthFunc = null_glDepthFunc,
    .p_glDepthMask = null_glDepthMask,
    .p_glDepthRange = null_glDepthRange,
    .p_glDisable = null_glDisable,
    .p_glDisableClientState = null_glDisableClientState,
    .p_glDrawArrays = null_glDrawArrays,
    .p_glDrawBuffer = null_glDrawBuffer,
    .p_glDrawElements = null_glDrawElements,
    .p_glDrawPixels = null_glDrawPixels,
    .p_glEdgeFlag = null_glEdgeFlag,
    .p_glEdgeFlagPointer = null_glEdgeFlagPointer,
    .p_glEdgeFlagv = null_glEdgeFlagv,
    .p_glEnable = null_glEnable,
    .p_glEnableClientState = null_glEnableClientState,
    .p_glEnd = null_glEnd,
    .p_glEndList = null_glEndList,
    .p_glEvalCoord1d = null_glEvalCoord1d,
    .p_glEvalCoord1dv = null_glEvalCoord1dv,
    .p_glEvalCoord1f = null_glEvalCoord1f,
    .p_glEvalCoord1fv = null_glEvalCoord1fv,
    .p_glEvalCoord2d = null_glEvalCoord2d,
    .p_glEvalCoord2dv = null_glEvalCoord2dv,
    .p_glEvalCoord2f = null_glEvalCoord2f,
    .p_glEvalCoord2fv = null_glEvalCoord2fv,
    .p_glEvalMesh1 = null_glEvalMesh1,
    .p_glEvalMesh2 = null_glEvalMesh2,
    .p_glEvalPoint1 = null_glEvalPoint1,
    .p_glEvalPoint2 = null_glEvalPoint2,
    .p_glFeedbackBuffer = null_glFeedbackBuffer,
    .p_glFinish = null_glFinish,
    .p_glFlush = null_glFlush,
    .p_glFogf = null_glFogf,
    .p_glFogfv = null_glFogfv,
    .p_glFogi = null_glFogi,
    .p_glFogiv = null_glFogiv,
    .p_glFrontFace = null_glFrontFace,
    .p_glFrustum = null_glFrustum,
    .p_glGenLists = null_glGenLists,
    .p_glGenTextures = null_glGenTextures,
    .p_glGetBooleanv = null_glGetBooleanv,
    .p_glGetClipPlane = null_glGetClipPlane,
    .p_glGetDoublev = null_glGetDoublev,
    .p_glGetError = null_glGetError,
    .p_glGetFloatv = null_glGetFloatv,
    .p_glGetIntegerv = null_glGetIntegerv,
    .p_glGetLightfv = null_glGetLightfv,
    .p_glGetLightiv = null_glGetLightiv,
    .p_glGetMapdv = null_glGetMapdv,
    .p_glGetMapfv = null_glGetMapfv,
    .p_glGetMapiv = null_glGetMapiv,
    .p_glGetMaterialfv = null_glGetMaterialfv,
    .p_glGetMaterialiv = null_glGetMaterialiv,
    .p_glGetPixelMapfv = null_glGetPixelMapfv,
    .p_glGetPixelMapuiv = null_glGetPixelMapuiv,
    .p_glGetPixelMapusv = null_glGetPixelMapusv,
    .p_glGetPointerv = null_glGetPointerv,
    .p_glGetPolygonStipple = null_glGetPolygonStipple,
    .p_glGetString = null_glGetString,
    .p_glGetTexEnvfv = null_glGetTexEnvfv,
    .p_glGetTexEnviv = null_glGetTexEnviv,
    .p_glGetTexGendv = null_glGetTexGendv,
    .p_glGetTexGenfv = null_glGetTexGenfv,
    .p_glGetTexGeniv = null_glGetTexGeniv,
    .p_glGetTexImage = null_glGetTexImage,
    .p_glGetTexLevelParameterfv = null_glGetTexLevelParameterfv,
    .p_glGetTexLevelParameteriv = null_glGetTexLevelParameteriv,
    .p_glGetTexParameterfv = null_glGetTexParameterfv,
    .p_glGetTexParameteriv = null_glGetTexParameteriv,
    .p_glHint = null_glHint,
    .p_glIndexMask = null_glIndexMask,
    .p_glIndexPointer = null_glIndexPointer,
    .p_glIndexd = null_glIndexd,
    .p_glIndexdv = null_glIndexdv,
    .p_glIndexf = null_glIndexf,
    .p_glIndexfv = null_glIndexfv,
    .p_glIndexi = null_glIndexi,
    .p_glIndexiv = null_glIndexiv,
    .p_glIndexs = null_glIndexs,
    .p_glIndexsv = null_glIndexsv,
    .p_glIndexub = null_glIndexub,
    .p_glIndexubv = null_glIndexubv,
    .p_glInitNames = null_glInitNames,
    .p_glInterleavedArrays = null_glInterleavedArrays,
    .p_glIsEnabled = null_glIsEnabled,
    .p_glIsList = null_glIsList,
    .p_glIsTexture = null_glIsTexture,
    .p_glLightModelf = null_glLightModelf,
    .p_glLightModelfv = null_glLightModelfv,
    .p_glLightModeli = null_glLightModeli,
    .p_glLightModeliv = null_glLightModeliv,
    .p_glLightf = null_glLightf,
    .p_glLightfv = null_glLightfv,
    .p_glLighti = null_glLighti,
    .p_glLightiv = null_glLightiv,
    .p_glLineStipple = null_glLineStipple,
    .p_glLineWidth = null_glLineWidth,
    .p_glListBase = null_glListBase,
    .p_glLoadIdentity = null_glLoadIdentity,
    .p_glLoadMatrixd = null_glLoadMatrixd,
    .p_glLoadMatrixf = null_glLoadMatrixf,
    .p_glLoadName = null_glLoadName,
    .p_glLogicOp = null_glLogicOp,
    .p_glMap1d = null_glMap1d,
    .p_glMap1f = null_glMap1f,
    .p_glMap2d = null_glMap2d,
    .p_glMap2f = null_glMap2f,
    .p_glMapGrid1d = null_glMapGrid1d,
    .p_glMapGrid1f = null_glMapGrid1f,
    .p_glMapGrid2d = null_glMapGrid2d,
    .p_glMapGrid2f = null_glMapGrid2f,
    .p_glMaterialf = null_glMaterialf,
    .p_glMaterialfv = null_glMaterialfv,
    .p_glMateriali = null_glMateriali,
    .p_glMaterialiv = null_glMaterialiv,
    .p_glMatrixMode = null_glMatrixMode,
    .p_glMultMatrixd = null_glMultMatrixd,
    .p_glMultMatrixf = null_glMultMatrixf,
    .p_glNewList = null_glNewList,
    .p_glNormal3b = null_glNormal3b,
    .p_glNormal3bv = null_glNormal3bv,
    .p_glNormal3d = null_glNormal3d,
    .p_glNormal3dv = null_glNormal3dv,
    .p_glNormal3f = null_glNormal3f,
    .p_glNormal3fv = null_glNormal3fv,
    .p_glNormal3i = null_glNormal3i,
    .p_glNormal3iv = null_glNormal3iv,
    .p_glNormal3s = null_glNormal3s,
    .p_glNormal3sv = null_glNormal3sv,
    .p_glNormalPointer = null_glNormalPointer,
    .p_glOrtho = null_glOrtho,
    .p_glPassThrough = null_glPassThrough,
    .p_glPixelMapfv = null_glPixelMapfv,
    .p_glPixelMapuiv = null_glPixelMapuiv,
    .p_glPixelMapusv = null_glPixelMapusv,
    .p_glPixelStoref = null_glPixelStoref,
    .p_glPixelStorei = null_glPixelStorei,
    .p_glPixelTransferf = null_glPixelTransferf,
    .p_glPixelTransferi = null_glPixelTransferi,
    .p_glPixelZoom = null_glPixelZoom,
    .p_glPointSize = null_glPointSize,
    .p_glPolygonMode = null_glPolygonMode,
    .p_glPolygonOffset = null_glPolygonOffset,
    .p_glPolygonStipple = null_glPolygonStipple,
    .p_glPopAttrib = null_glPopAttrib,
    .p_glPopClientAttrib = null_glPopClientAttrib,
    .p_glPopMatrix = null_glPopMatrix,
    .p_glPopName = null_glPopName,
    .p_glPrioritizeTextures = null_glPrioritizeTextures,
    .p_glPushAttrib = null_glPushAttrib,
    .p_glPushClientAttrib = null_glPushClientAttrib,
    .p_glPushMatrix = null_glPushMatrix,
    .p_glPushName = null_glPushName,
    .p_glRasterPos2d = null_glRasterPos2d,
    .p_glRasterPos2dv = null_glRasterPos2dv,
    .p_glRasterPos2f = null_glRasterPos2f,
    .p_glRasterPos2fv = null_glRasterPos2fv,
    .p_glRasterPos2i = null_glRasterPos2i,
    .p_glRasterPos2iv = null_glRasterPos2iv,
    .p_glRasterPos2s = null_glRasterPos2s,
    .p_glRasterPos2sv = null_glRasterPos2sv,
    .p_glRasterPos3d = null_glRasterPos3d,
    .p_glRasterPos3dv = null_glRasterPos3dv,
    .p_glRasterPos3f = null_glRasterPos3f,
    .p_glRasterPos3fv = null_glRasterPos3fv,
    .p_glRasterPos3i = null_glRasterPos3i,
    .p_glRasterPos3iv = null_glRasterPos3iv,
    .p_glRasterPos3s = null_glRasterPos3s,
    .p_glRasterPos3sv = null_glRasterPos3sv,
    .p_glRasterPos4d = null_glRasterPos4d,
    .p_glRasterPos4dv = null_glRasterPos4dv,
    .p_glRasterPos4f = null_glRasterPos4f,
    .p_glRasterPos4fv = null_glRasterPos4fv,
    .p_glRasterPos4i = null_glRasterPos4i,
    .p_glRasterPos4iv = null_glRasterPos4iv,
    .p_glRasterPos4s = null_glRasterPos4s,
    .p_glRasterPos4sv = null_glRasterPos4sv,
    .p_glReadBuffer = null_glReadBuffer,
    .p_glReadPixels = null_glReadPixels,
    .p_glRectd = null_glRectd,
    .p_glRectdv = null_glRectdv,
    .p_glRectf = null_glRectf,
    .p_glRectfv = null_glRectfv,
    .p_glRecti = null_glRecti,
    .p_glRectiv = null_glRectiv,
    .p_glRects = null_glRects,
    .p_glRectsv = null_glRectsv,
    .p_glRenderMode = null_glRenderMode,
    .p_glRotated = null_glRotated,
    .p_glRotatef = null_glRotatef,
    .p_glScaled = null_glScaled,
    .p_glScalef = null_glScalef,
    .p_glScissor = null_glScissor,
    .p_glSelectBuffer = null_glSelectBuffer,
    .p_glShadeModel = null_glShadeModel,
    .p_glStencilFunc = null_glStencilFunc,
    .p_glStencilMask = null_glStencilMask,
    .p_glStencilOp = null_glStencilOp,
    .p_glTexCoord1d = null_glTexCoord1d,
    .p_glTexCoord1dv = null_glTexCoord1dv,
    .p_glTexCoord1f = null_glTexCoord1f,
    .p_glTexCoord1fv = null_glTexCoord1fv,
    .p_glTexCoord1i = null_glTexCoord1i,
    .p_glTexCoord1iv = null_glTexCoord1iv,
    .p_glTexCoord1s = null_glTexCoord1s,
    .p_glTexCoord1sv = null_glTexCoord1sv,
    .p_glTexCoord2d = null_glTexCoord2d,
    .p_glTexCoord2dv = null_glTexCoord2dv,
    .p_glTexCoord2f = null_glTexCoord2f,
    .p_glTexCoord2fv = null_glTexCoord2fv,
    .p_glTexCoord2i = null_glTexCoord2i,
    .p_glTexCoord2iv = null_glTexCoord2iv,
    .p_glTexCoord2s = null_glTexCoord2s,
    .p_glTexCoord2sv = null_glTexCoord2sv,
    .p_glTexCoord3d = null_glTexCoord3d,
    .p_glTexCoord3dv = null_glTexCoord3dv,
    .p_glTexCoord3f = null_glTexCoord3f,
    .p_glTexCoord3fv = null_glTexCoord3fv,
    .p_glTexCoord3i = null_glTexCoord3i,
    .p_glTexCoord3iv = null_glTexCoord3iv,
    .p_glTexCoord3s = null_glTexCoord3s,
    .p_glTexCoord3sv = null_glTexCoord3sv,
    .p_glTexCoord4d = null_glTexCoord4d,
    .p_glTexCoord4dv = null_glTexCoord4dv,
    .p_glTexCoord4f = null_glTexCoord4f,
    .p_glTexCoord4fv = null_glTexCoord4fv,
    .p_glTexCoord4i = null_glTexCoord4i,
    .p_glTexCoord4iv = null_glTexCoord4iv,
    .p_glTexCoord4s = null_glTexCoord4s,
    .p_glTexCoord4sv = null_glTexCoord4sv,
    .p_glTexCoordPointer = null_glTexCoordPointer,
    .p_glTexEnvf = null_glTexEnvf,
    .p_glTexEnvfv = null_glTexEnvfv,
    .p_glTexEnvi = null_glTexEnvi,
    .p_glTexEnviv = null_glTexEnviv,
    .p_glTexGend = null_glTexGend,
    .p_glTexGendv = null_glTexGendv,
    .p_glTexGenf = null_glTexGenf,
    .p_glTexGenfv = null_glTexGenfv,
    .p_glTexGeni = null_glTexGeni,
    .p_glTexGeniv = null_glTexGeniv,
    .p_glTexImage1D = null_glTexImage1D,
    .p_glTexImage2D = null_glTexImage2D,
    .p_glTexParameterf = null_glTexParameterf,
    .p_glTexParameterfv = null_glTexParameterfv,
    .p_glTexParameteri = null_glTexParameteri,
    .p_glTexParameteriv = null_glTexParameteriv,
    .p_glTexSubImage1D = null_glTexSubImage1D,
    .p_glTexSubImage2D = null_glTexSubImage2D,
    .p_glTranslated = null_glTranslated,
    .p_glTranslatef = null_glTranslatef,
    .p_glVertex2d = null_glVertex2d,
    .p_glVertex2dv = null_glVertex2dv,
    .p_glVertex2f = null_glVertex2f,
    .p_glVertex2fv = null_glVertex2fv,
    .p_glVertex2i = null_glVertex2i,
    .p_glVertex2iv = null_glVertex2iv,
    .p_glVertex2s = null_glVertex2s,
    .p_glVertex2sv = null_glVertex2sv,
    .p_glVertex3d = null_glVertex3d,
    .p_glVertex3dv = null_glVertex3dv,
    .p_glVertex3f = null_glVertex3f,
    .p_glVertex3fv = null_glVertex3fv,
    .p_glVertex3i = null_glVertex3i,
    .p_glVertex3iv = null_glVertex3iv,
    .p_glVertex3s = null_glVertex3s,
    .p_glVertex3sv = null_glVertex3sv,
    .p_glVertex4d = null_glVertex4d,
    .p_glVertex4dv = null_glVertex4dv,
    .p_glVertex4f = null_glVertex4f,
    .p_glVertex4fv = null_glVertex4fv,
    .p_glVertex4i = null_glVertex4i,
    .p_glVertex4iv = null_glVertex4iv,
    .p_glVertex4s = null_glVertex4s,
    .p_glVertex4sv = null_glVertex4sv,
    .p_glVertexPointer = null_glVertexPointer,
    .p_glViewport = null_glViewport,
};
