/*
 * THIS FILE IS AUTOMATICALLY GENERATED BY gen_noop.pl
 * DO NOT EDIT!!
 */
#include <X11/Xlib.h>
#include <GL/glx.h>
#include "compiler.h"
#include "libglxgl.h"
#include "glvnd_pthread.h"

#define LOAD_GLX_FUNC(name) __glXGLLoadGLXFunction(#name, (__GLXextFuncPtr *) &__real_##name, &__mutex_##name)

typedef void * (*fn_glXAllocateMemoryNV_ptr)(GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority);
static fn_glXAllocateMemoryNV_ptr __real_glXAllocateMemoryNV;
static glvnd_mutex_t __mutex_glXAllocateMemoryNV = GLVND_MUTEX_INITIALIZER;
PUBLIC void * glXAllocateMemoryNV(GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority)
{
    fn_glXAllocateMemoryNV_ptr _real = (fn_glXAllocateMemoryNV_ptr) LOAD_GLX_FUNC(glXAllocateMemoryNV);
    if(_real != NULL) {
        return _real(size, readfreq, writefreq, priority);
    } else {
        return NULL;
    }
}

typedef int (*fn_glXBindChannelToWindowSGIX_ptr)(Display *display, int screen, int channel, Window window);
static fn_glXBindChannelToWindowSGIX_ptr __real_glXBindChannelToWindowSGIX;
static glvnd_mutex_t __mutex_glXBindChannelToWindowSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXBindChannelToWindowSGIX(Display *display, int screen, int channel, Window window)
{
    fn_glXBindChannelToWindowSGIX_ptr _real = (fn_glXBindChannelToWindowSGIX_ptr) LOAD_GLX_FUNC(glXBindChannelToWindowSGIX);
    if(_real != NULL) {
        return _real(display, screen, channel, window);
    } else {
        return 0;
    }
}

typedef int (*fn_glXBindHyperpipeSGIX_ptr)(Display *dpy, int hpId);
static fn_glXBindHyperpipeSGIX_ptr __real_glXBindHyperpipeSGIX;
static glvnd_mutex_t __mutex_glXBindHyperpipeSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXBindHyperpipeSGIX(Display *dpy, int hpId)
{
    fn_glXBindHyperpipeSGIX_ptr _real = (fn_glXBindHyperpipeSGIX_ptr) LOAD_GLX_FUNC(glXBindHyperpipeSGIX);
    if(_real != NULL) {
        return _real(dpy, hpId);
    } else {
        return 0;
    }
}

typedef Bool (*fn_glXBindSwapBarrierNV_ptr)(Display *dpy, GLuint group, GLuint barrier);
static fn_glXBindSwapBarrierNV_ptr __real_glXBindSwapBarrierNV;
static glvnd_mutex_t __mutex_glXBindSwapBarrierNV = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXBindSwapBarrierNV(Display *dpy, GLuint group, GLuint barrier)
{
    fn_glXBindSwapBarrierNV_ptr _real = (fn_glXBindSwapBarrierNV_ptr) LOAD_GLX_FUNC(glXBindSwapBarrierNV);
    if(_real != NULL) {
        return _real(dpy, group, barrier);
    } else {
        return False;
    }
}

typedef void (*fn_glXBindSwapBarrierSGIX_ptr)(Display *dpy, GLXDrawable drawable, int barrier);
static fn_glXBindSwapBarrierSGIX_ptr __real_glXBindSwapBarrierSGIX;
static glvnd_mutex_t __mutex_glXBindSwapBarrierSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXBindSwapBarrierSGIX(Display *dpy, GLXDrawable drawable, int barrier)
{
    fn_glXBindSwapBarrierSGIX_ptr _real = (fn_glXBindSwapBarrierSGIX_ptr) LOAD_GLX_FUNC(glXBindSwapBarrierSGIX);
    if(_real != NULL) {
        _real(dpy, drawable, barrier);
    }
}

typedef void (*fn_glXBindTexImageEXT_ptr)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
static fn_glXBindTexImageEXT_ptr __real_glXBindTexImageEXT;
static glvnd_mutex_t __mutex_glXBindTexImageEXT = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXBindTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list)
{
    fn_glXBindTexImageEXT_ptr _real = (fn_glXBindTexImageEXT_ptr) LOAD_GLX_FUNC(glXBindTexImageEXT);
    if(_real != NULL) {
        _real(dpy, drawable, buffer, attrib_list);
    }
}

typedef int (*fn_glXBindVideoCaptureDeviceNV_ptr)(Display *dpy, unsigned int video_capture_slot, GLXVideoCaptureDeviceNV device);
static fn_glXBindVideoCaptureDeviceNV_ptr __real_glXBindVideoCaptureDeviceNV;
static glvnd_mutex_t __mutex_glXBindVideoCaptureDeviceNV = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXBindVideoCaptureDeviceNV(Display *dpy, unsigned int video_capture_slot, GLXVideoCaptureDeviceNV device)
{
    fn_glXBindVideoCaptureDeviceNV_ptr _real = (fn_glXBindVideoCaptureDeviceNV_ptr) LOAD_GLX_FUNC(glXBindVideoCaptureDeviceNV);
    if(_real != NULL) {
        return _real(dpy, video_capture_slot, device);
    } else {
        return 0;
    }
}

typedef int (*fn_glXBindVideoDeviceNV_ptr)(Display *dpy, unsigned int video_slot, unsigned int video_device, const int *attrib_list);
static fn_glXBindVideoDeviceNV_ptr __real_glXBindVideoDeviceNV;
static glvnd_mutex_t __mutex_glXBindVideoDeviceNV = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXBindVideoDeviceNV(Display *dpy, unsigned int video_slot, unsigned int video_device, const int *attrib_list)
{
    fn_glXBindVideoDeviceNV_ptr _real = (fn_glXBindVideoDeviceNV_ptr) LOAD_GLX_FUNC(glXBindVideoDeviceNV);
    if(_real != NULL) {
        return _real(dpy, video_slot, video_device, attrib_list);
    } else {
        return 0;
    }
}

typedef int (*fn_glXBindVideoImageNV_ptr)(Display *dpy, GLXVideoDeviceNV VideoDevice, GLXPbuffer pbuf, int iVideoBuffer);
static fn_glXBindVideoImageNV_ptr __real_glXBindVideoImageNV;
static glvnd_mutex_t __mutex_glXBindVideoImageNV = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXBindVideoImageNV(Display *dpy, GLXVideoDeviceNV VideoDevice, GLXPbuffer pbuf, int iVideoBuffer)
{
    fn_glXBindVideoImageNV_ptr _real = (fn_glXBindVideoImageNV_ptr) LOAD_GLX_FUNC(glXBindVideoImageNV);
    if(_real != NULL) {
        return _real(dpy, VideoDevice, pbuf, iVideoBuffer);
    } else {
        return 0;
    }
}

typedef void (*fn_glXBlitContextFramebufferAMD_ptr)(GLXContext dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
static fn_glXBlitContextFramebufferAMD_ptr __real_glXBlitContextFramebufferAMD;
static glvnd_mutex_t __mutex_glXBlitContextFramebufferAMD = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXBlitContextFramebufferAMD(GLXContext dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
{
    fn_glXBlitContextFramebufferAMD_ptr _real = (fn_glXBlitContextFramebufferAMD_ptr) LOAD_GLX_FUNC(glXBlitContextFramebufferAMD);
    if(_real != NULL) {
        _real(dstCtx, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
    }
}

typedef int (*fn_glXChannelRectSGIX_ptr)(Display *display, int screen, int channel, int x, int y, int w, int h);
static fn_glXChannelRectSGIX_ptr __real_glXChannelRectSGIX;
static glvnd_mutex_t __mutex_glXChannelRectSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXChannelRectSGIX(Display *display, int screen, int channel, int x, int y, int w, int h)
{
    fn_glXChannelRectSGIX_ptr _real = (fn_glXChannelRectSGIX_ptr) LOAD_GLX_FUNC(glXChannelRectSGIX);
    if(_real != NULL) {
        return _real(display, screen, channel, x, y, w, h);
    } else {
        return 0;
    }
}

typedef int (*fn_glXChannelRectSyncSGIX_ptr)(Display *display, int screen, int channel, GLenum synctype);
static fn_glXChannelRectSyncSGIX_ptr __real_glXChannelRectSyncSGIX;
static glvnd_mutex_t __mutex_glXChannelRectSyncSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXChannelRectSyncSGIX(Display *display, int screen, int channel, GLenum synctype)
{
    fn_glXChannelRectSyncSGIX_ptr _real = (fn_glXChannelRectSyncSGIX_ptr) LOAD_GLX_FUNC(glXChannelRectSyncSGIX);
    if(_real != NULL) {
        return _real(display, screen, channel, synctype);
    } else {
        return 0;
    }
}

PUBLIC GLXFBConfig * glXChooseFBConfig(Display *dpy, int screen, const int *attrib_list, int *nelements)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXChooseFBConfig(dpy, screen, attrib_list, nelements);
}

typedef GLXFBConfigSGIX * (*fn_glXChooseFBConfigSGIX_ptr)(Display *dpy, int screen, int *attrib_list, int *nelements);
static fn_glXChooseFBConfigSGIX_ptr __real_glXChooseFBConfigSGIX;
static glvnd_mutex_t __mutex_glXChooseFBConfigSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC GLXFBConfigSGIX * glXChooseFBConfigSGIX(Display *dpy, int screen, int *attrib_list, int *nelements)
{
    fn_glXChooseFBConfigSGIX_ptr _real = (fn_glXChooseFBConfigSGIX_ptr) LOAD_GLX_FUNC(glXChooseFBConfigSGIX);
    if(_real != NULL) {
        return _real(dpy, screen, attrib_list, nelements);
    } else {
        return NULL;
    }
}

PUBLIC XVisualInfo * glXChooseVisual(Display *dpy, int screen, int *attribList)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXChooseVisual(dpy, screen, attribList);
}

typedef void (*fn_glXCopyBufferSubDataNV_ptr)(Display *dpy, GLXContext readCtx, GLXContext writeCtx, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
static fn_glXCopyBufferSubDataNV_ptr __real_glXCopyBufferSubDataNV;
static glvnd_mutex_t __mutex_glXCopyBufferSubDataNV = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXCopyBufferSubDataNV(Display *dpy, GLXContext readCtx, GLXContext writeCtx, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
    fn_glXCopyBufferSubDataNV_ptr _real = (fn_glXCopyBufferSubDataNV_ptr) LOAD_GLX_FUNC(glXCopyBufferSubDataNV);
    if(_real != NULL) {
        _real(dpy, readCtx, writeCtx, readTarget, writeTarget, readOffset, writeOffset, size);
    }
}

PUBLIC void glXCopyContext(Display *dpy, GLXContext src, GLXContext dst, unsigned long mask)
{
    __GLXGL_CORE_FUNCTIONS.ptr_glXCopyContext(dpy, src, dst, mask);
}

typedef void (*fn_glXCopyImageSubDataNV_ptr)(Display *dpy, GLXContext srcCtx, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLXContext dstCtx, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
static fn_glXCopyImageSubDataNV_ptr __real_glXCopyImageSubDataNV;
static glvnd_mutex_t __mutex_glXCopyImageSubDataNV = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXCopyImageSubDataNV(Display *dpy, GLXContext srcCtx, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLXContext dstCtx, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth)
{
    fn_glXCopyImageSubDataNV_ptr _real = (fn_glXCopyImageSubDataNV_ptr) LOAD_GLX_FUNC(glXCopyImageSubDataNV);
    if(_real != NULL) {
        _real(dpy, srcCtx, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstCtx, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth);
    }
}

typedef void (*fn_glXCopySubBufferMESA_ptr)(Display *dpy, GLXDrawable drawable, int x, int y, int width, int height);
static fn_glXCopySubBufferMESA_ptr __real_glXCopySubBufferMESA;
static glvnd_mutex_t __mutex_glXCopySubBufferMESA = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXCopySubBufferMESA(Display *dpy, GLXDrawable drawable, int x, int y, int width, int height)
{
    fn_glXCopySubBufferMESA_ptr _real = (fn_glXCopySubBufferMESA_ptr) LOAD_GLX_FUNC(glXCopySubBufferMESA);
    if(_real != NULL) {
        _real(dpy, drawable, x, y, width, height);
    }
}

typedef GLXContext (*fn_glXCreateAssociatedContextAMD_ptr)(unsigned int id, GLXContext share_list);
static fn_glXCreateAssociatedContextAMD_ptr __real_glXCreateAssociatedContextAMD;
static glvnd_mutex_t __mutex_glXCreateAssociatedContextAMD = GLVND_MUTEX_INITIALIZER;
PUBLIC GLXContext glXCreateAssociatedContextAMD(unsigned int id, GLXContext share_list)
{
    fn_glXCreateAssociatedContextAMD_ptr _real = (fn_glXCreateAssociatedContextAMD_ptr) LOAD_GLX_FUNC(glXCreateAssociatedContextAMD);
    if(_real != NULL) {
        return _real(id, share_list);
    } else {
        return NULL;
    }
}

typedef GLXContext (*fn_glXCreateAssociatedContextAttribsAMD_ptr)(unsigned int id, GLXContext share_context, const int *attribList);
static fn_glXCreateAssociatedContextAttribsAMD_ptr __real_glXCreateAssociatedContextAttribsAMD;
static glvnd_mutex_t __mutex_glXCreateAssociatedContextAttribsAMD = GLVND_MUTEX_INITIALIZER;
PUBLIC GLXContext glXCreateAssociatedContextAttribsAMD(unsigned int id, GLXContext share_context, const int *attribList)
{
    fn_glXCreateAssociatedContextAttribsAMD_ptr _real = (fn_glXCreateAssociatedContextAttribsAMD_ptr) LOAD_GLX_FUNC(glXCreateAssociatedContextAttribsAMD);
    if(_real != NULL) {
        return _real(id, share_context, attribList);
    } else {
        return NULL;
    }
}

PUBLIC GLXContext glXCreateContext(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXCreateContext(dpy, vis, shareList, direct);
}

typedef GLXContext (*fn_glXCreateContextAttribsARB_ptr)(Display *dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list);
static fn_glXCreateContextAttribsARB_ptr __real_glXCreateContextAttribsARB;
static glvnd_mutex_t __mutex_glXCreateContextAttribsARB = GLVND_MUTEX_INITIALIZER;
PUBLIC GLXContext glXCreateContextAttribsARB(Display *dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list)
{
    fn_glXCreateContextAttribsARB_ptr _real = (fn_glXCreateContextAttribsARB_ptr) LOAD_GLX_FUNC(glXCreateContextAttribsARB);
    if(_real != NULL) {
        return _real(dpy, config, share_context, direct, attrib_list);
    } else {
        return NULL;
    }
}

typedef GLXContext (*fn_glXCreateContextWithConfigSGIX_ptr)(Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct);
static fn_glXCreateContextWithConfigSGIX_ptr __real_glXCreateContextWithConfigSGIX;
static glvnd_mutex_t __mutex_glXCreateContextWithConfigSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC GLXContext glXCreateContextWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct)
{
    fn_glXCreateContextWithConfigSGIX_ptr _real = (fn_glXCreateContextWithConfigSGIX_ptr) LOAD_GLX_FUNC(glXCreateContextWithConfigSGIX);
    if(_real != NULL) {
        return _real(dpy, config, render_type, share_list, direct);
    } else {
        return NULL;
    }
}

typedef GLXPbufferSGIX (*fn_glXCreateGLXPbufferSGIX_ptr)(Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list);
static fn_glXCreateGLXPbufferSGIX_ptr __real_glXCreateGLXPbufferSGIX;
static glvnd_mutex_t __mutex_glXCreateGLXPbufferSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC GLXPbufferSGIX glXCreateGLXPbufferSGIX(Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list)
{
    fn_glXCreateGLXPbufferSGIX_ptr _real = (fn_glXCreateGLXPbufferSGIX_ptr) LOAD_GLX_FUNC(glXCreateGLXPbufferSGIX);
    if(_real != NULL) {
        return _real(dpy, config, width, height, attrib_list);
    } else {
        return None;
    }
}

PUBLIC GLXPixmap glXCreateGLXPixmap(Display *dpy, XVisualInfo *visual, Pixmap pixmap)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXCreateGLXPixmap(dpy, visual, pixmap);
}

typedef GLXPixmap (*fn_glXCreateGLXPixmapMESA_ptr)(Display *dpy, XVisualInfo *visual, Pixmap pixmap, Colormap cmap);
static fn_glXCreateGLXPixmapMESA_ptr __real_glXCreateGLXPixmapMESA;
static glvnd_mutex_t __mutex_glXCreateGLXPixmapMESA = GLVND_MUTEX_INITIALIZER;
PUBLIC GLXPixmap glXCreateGLXPixmapMESA(Display *dpy, XVisualInfo *visual, Pixmap pixmap, Colormap cmap)
{
    fn_glXCreateGLXPixmapMESA_ptr _real = (fn_glXCreateGLXPixmapMESA_ptr) LOAD_GLX_FUNC(glXCreateGLXPixmapMESA);
    if(_real != NULL) {
        return _real(dpy, visual, pixmap, cmap);
    } else {
        return None;
    }
}

typedef GLXPixmap (*fn_glXCreateGLXPixmapWithConfigSGIX_ptr)(Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap);
static fn_glXCreateGLXPixmapWithConfigSGIX_ptr __real_glXCreateGLXPixmapWithConfigSGIX;
static glvnd_mutex_t __mutex_glXCreateGLXPixmapWithConfigSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC GLXPixmap glXCreateGLXPixmapWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap)
{
    fn_glXCreateGLXPixmapWithConfigSGIX_ptr _real = (fn_glXCreateGLXPixmapWithConfigSGIX_ptr) LOAD_GLX_FUNC(glXCreateGLXPixmapWithConfigSGIX);
    if(_real != NULL) {
        return _real(dpy, config, pixmap);
    } else {
        return None;
    }
}

PUBLIC GLXContext glXCreateNewContext(Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXCreateNewContext(dpy, config, render_type, share_list, direct);
}

PUBLIC GLXPbuffer glXCreatePbuffer(Display *dpy, GLXFBConfig config, const int *attrib_list)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXCreatePbuffer(dpy, config, attrib_list);
}

PUBLIC GLXPixmap glXCreatePixmap(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attrib_list)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXCreatePixmap(dpy, config, pixmap, attrib_list);
}

PUBLIC GLXWindow glXCreateWindow(Display *dpy, GLXFBConfig config, Window win, const int *attrib_list)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXCreateWindow(dpy, config, win, attrib_list);
}

typedef void (*fn_glXCushionSGI_ptr)(Display *dpy, Window window, float cushion);
static fn_glXCushionSGI_ptr __real_glXCushionSGI;
static glvnd_mutex_t __mutex_glXCushionSGI = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXCushionSGI(Display *dpy, Window window, float cushion)
{
    fn_glXCushionSGI_ptr _real = (fn_glXCushionSGI_ptr) LOAD_GLX_FUNC(glXCushionSGI);
    if(_real != NULL) {
        _real(dpy, window, cushion);
    }
}

typedef Bool (*fn_glXDelayBeforeSwapNV_ptr)(Display *dpy, GLXDrawable drawable, GLfloat seconds);
static fn_glXDelayBeforeSwapNV_ptr __real_glXDelayBeforeSwapNV;
static glvnd_mutex_t __mutex_glXDelayBeforeSwapNV = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXDelayBeforeSwapNV(Display *dpy, GLXDrawable drawable, GLfloat seconds)
{
    fn_glXDelayBeforeSwapNV_ptr _real = (fn_glXDelayBeforeSwapNV_ptr) LOAD_GLX_FUNC(glXDelayBeforeSwapNV);
    if(_real != NULL) {
        return _real(dpy, drawable, seconds);
    } else {
        return False;
    }
}

typedef Bool (*fn_glXDeleteAssociatedContextAMD_ptr)(GLXContext ctx);
static fn_glXDeleteAssociatedContextAMD_ptr __real_glXDeleteAssociatedContextAMD;
static glvnd_mutex_t __mutex_glXDeleteAssociatedContextAMD = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXDeleteAssociatedContextAMD(GLXContext ctx)
{
    fn_glXDeleteAssociatedContextAMD_ptr _real = (fn_glXDeleteAssociatedContextAMD_ptr) LOAD_GLX_FUNC(glXDeleteAssociatedContextAMD);
    if(_real != NULL) {
        return _real(ctx);
    } else {
        return False;
    }
}

PUBLIC void glXDestroyContext(Display *dpy, GLXContext ctx)
{
    __GLXGL_CORE_FUNCTIONS.ptr_glXDestroyContext(dpy, ctx);
}

typedef void (*fn_glXDestroyGLXPbufferSGIX_ptr)(Display *dpy, GLXPbufferSGIX pbuf);
static fn_glXDestroyGLXPbufferSGIX_ptr __real_glXDestroyGLXPbufferSGIX;
static glvnd_mutex_t __mutex_glXDestroyGLXPbufferSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXDestroyGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf)
{
    fn_glXDestroyGLXPbufferSGIX_ptr _real = (fn_glXDestroyGLXPbufferSGIX_ptr) LOAD_GLX_FUNC(glXDestroyGLXPbufferSGIX);
    if(_real != NULL) {
        _real(dpy, pbuf);
    }
}

PUBLIC void glXDestroyGLXPixmap(Display *dpy, GLXPixmap pixmap)
{
    __GLXGL_CORE_FUNCTIONS.ptr_glXDestroyGLXPixmap(dpy, pixmap);
}

typedef int (*fn_glXDestroyHyperpipeConfigSGIX_ptr)(Display *dpy, int hpId);
static fn_glXDestroyHyperpipeConfigSGIX_ptr __real_glXDestroyHyperpipeConfigSGIX;
static glvnd_mutex_t __mutex_glXDestroyHyperpipeConfigSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXDestroyHyperpipeConfigSGIX(Display *dpy, int hpId)
{
    fn_glXDestroyHyperpipeConfigSGIX_ptr _real = (fn_glXDestroyHyperpipeConfigSGIX_ptr) LOAD_GLX_FUNC(glXDestroyHyperpipeConfigSGIX);
    if(_real != NULL) {
        return _real(dpy, hpId);
    } else {
        return 0;
    }
}

PUBLIC void glXDestroyPbuffer(Display *dpy, GLXPbuffer pbuf)
{
    __GLXGL_CORE_FUNCTIONS.ptr_glXDestroyPbuffer(dpy, pbuf);
}

PUBLIC void glXDestroyPixmap(Display *dpy, GLXPixmap pixmap)
{
    __GLXGL_CORE_FUNCTIONS.ptr_glXDestroyPixmap(dpy, pixmap);
}

PUBLIC void glXDestroyWindow(Display *dpy, GLXWindow win)
{
    __GLXGL_CORE_FUNCTIONS.ptr_glXDestroyWindow(dpy, win);
}

typedef GLXVideoCaptureDeviceNV * (*fn_glXEnumerateVideoCaptureDevicesNV_ptr)(Display *dpy, int screen, int *nelements);
static fn_glXEnumerateVideoCaptureDevicesNV_ptr __real_glXEnumerateVideoCaptureDevicesNV;
static glvnd_mutex_t __mutex_glXEnumerateVideoCaptureDevicesNV = GLVND_MUTEX_INITIALIZER;
PUBLIC GLXVideoCaptureDeviceNV * glXEnumerateVideoCaptureDevicesNV(Display *dpy, int screen, int *nelements)
{
    fn_glXEnumerateVideoCaptureDevicesNV_ptr _real = (fn_glXEnumerateVideoCaptureDevicesNV_ptr) LOAD_GLX_FUNC(glXEnumerateVideoCaptureDevicesNV);
    if(_real != NULL) {
        return _real(dpy, screen, nelements);
    } else {
        return NULL;
    }
}

typedef unsigned int * (*fn_glXEnumerateVideoDevicesNV_ptr)(Display *dpy, int screen, int *nelements);
static fn_glXEnumerateVideoDevicesNV_ptr __real_glXEnumerateVideoDevicesNV;
static glvnd_mutex_t __mutex_glXEnumerateVideoDevicesNV = GLVND_MUTEX_INITIALIZER;
PUBLIC unsigned int * glXEnumerateVideoDevicesNV(Display *dpy, int screen, int *nelements)
{
    fn_glXEnumerateVideoDevicesNV_ptr _real = (fn_glXEnumerateVideoDevicesNV_ptr) LOAD_GLX_FUNC(glXEnumerateVideoDevicesNV);
    if(_real != NULL) {
        return _real(dpy, screen, nelements);
    } else {
        return NULL;
    }
}

typedef void (*fn_glXFreeContextEXT_ptr)(Display *dpy, GLXContext context);
static fn_glXFreeContextEXT_ptr __real_glXFreeContextEXT;
static glvnd_mutex_t __mutex_glXFreeContextEXT = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXFreeContextEXT(Display *dpy, GLXContext context)
{
    fn_glXFreeContextEXT_ptr _real = (fn_glXFreeContextEXT_ptr) LOAD_GLX_FUNC(glXFreeContextEXT);
    if(_real != NULL) {
        _real(dpy, context);
    }
}

typedef void (*fn_glXFreeMemoryNV_ptr)(void *pointer);
static fn_glXFreeMemoryNV_ptr __real_glXFreeMemoryNV;
static glvnd_mutex_t __mutex_glXFreeMemoryNV = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXFreeMemoryNV(void *pointer)
{
    fn_glXFreeMemoryNV_ptr _real = (fn_glXFreeMemoryNV_ptr) LOAD_GLX_FUNC(glXFreeMemoryNV);
    if(_real != NULL) {
        _real(pointer);
    }
}

typedef unsigned int (*fn_glXGetAGPOffsetMESA_ptr)(const void *pointer);
static fn_glXGetAGPOffsetMESA_ptr __real_glXGetAGPOffsetMESA;
static glvnd_mutex_t __mutex_glXGetAGPOffsetMESA = GLVND_MUTEX_INITIALIZER;
PUBLIC unsigned int glXGetAGPOffsetMESA(const void *pointer)
{
    fn_glXGetAGPOffsetMESA_ptr _real = (fn_glXGetAGPOffsetMESA_ptr) LOAD_GLX_FUNC(glXGetAGPOffsetMESA);
    if(_real != NULL) {
        return _real(pointer);
    } else {
        return 0;
    }
}

PUBLIC const char * glXGetClientString(Display *dpy, int name)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXGetClientString(dpy, name);
}

PUBLIC int glXGetConfig(Display *dpy, XVisualInfo *visual, int attrib, int *value)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXGetConfig(dpy, visual, attrib, value);
}

typedef unsigned int (*fn_glXGetContextGPUIDAMD_ptr)(GLXContext ctx);
static fn_glXGetContextGPUIDAMD_ptr __real_glXGetContextGPUIDAMD;
static glvnd_mutex_t __mutex_glXGetContextGPUIDAMD = GLVND_MUTEX_INITIALIZER;
PUBLIC unsigned int glXGetContextGPUIDAMD(GLXContext ctx)
{
    fn_glXGetContextGPUIDAMD_ptr _real = (fn_glXGetContextGPUIDAMD_ptr) LOAD_GLX_FUNC(glXGetContextGPUIDAMD);
    if(_real != NULL) {
        return _real(ctx);
    } else {
        return 0;
    }
}

typedef GLXContextID (*fn_glXGetContextIDEXT_ptr)(const GLXContext context);
static fn_glXGetContextIDEXT_ptr __real_glXGetContextIDEXT;
static glvnd_mutex_t __mutex_glXGetContextIDEXT = GLVND_MUTEX_INITIALIZER;
PUBLIC GLXContextID glXGetContextIDEXT(const GLXContext context)
{
    fn_glXGetContextIDEXT_ptr _real = (fn_glXGetContextIDEXT_ptr) LOAD_GLX_FUNC(glXGetContextIDEXT);
    if(_real != NULL) {
        return _real(context);
    } else {
        return None;
    }
}

typedef GLXContext (*fn_glXGetCurrentAssociatedContextAMD_ptr)(void);
static fn_glXGetCurrentAssociatedContextAMD_ptr __real_glXGetCurrentAssociatedContextAMD;
static glvnd_mutex_t __mutex_glXGetCurrentAssociatedContextAMD = GLVND_MUTEX_INITIALIZER;
PUBLIC GLXContext glXGetCurrentAssociatedContextAMD(void)
{
    fn_glXGetCurrentAssociatedContextAMD_ptr _real = (fn_glXGetCurrentAssociatedContextAMD_ptr) LOAD_GLX_FUNC(glXGetCurrentAssociatedContextAMD);
    if(_real != NULL) {
        return _real();
    } else {
        return NULL;
    }
}

PUBLIC GLXContext glXGetCurrentContext(void)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXGetCurrentContext();
}

typedef Display * (*fn_glXGetCurrentDisplay_ptr)(void);
static fn_glXGetCurrentDisplay_ptr __real_glXGetCurrentDisplay;
static glvnd_mutex_t __mutex_glXGetCurrentDisplay = GLVND_MUTEX_INITIALIZER;
PUBLIC Display * glXGetCurrentDisplay(void)
{
    fn_glXGetCurrentDisplay_ptr _real = (fn_glXGetCurrentDisplay_ptr) LOAD_GLX_FUNC(glXGetCurrentDisplay);
    if(_real != NULL) {
        return _real();
    } else {
        return NULL;
    }
}

typedef Display * (*fn_glXGetCurrentDisplayEXT_ptr)(void);
static fn_glXGetCurrentDisplayEXT_ptr __real_glXGetCurrentDisplayEXT;
static glvnd_mutex_t __mutex_glXGetCurrentDisplayEXT = GLVND_MUTEX_INITIALIZER;
PUBLIC Display * glXGetCurrentDisplayEXT(void)
{
    fn_glXGetCurrentDisplayEXT_ptr _real = (fn_glXGetCurrentDisplayEXT_ptr) LOAD_GLX_FUNC(glXGetCurrentDisplayEXT);
    if(_real != NULL) {
        return _real();
    } else {
        return NULL;
    }
}

PUBLIC GLXDrawable glXGetCurrentDrawable(void)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXGetCurrentDrawable();
}

PUBLIC GLXDrawable glXGetCurrentReadDrawable(void)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXGetCurrentReadDrawable();
}

typedef GLXDrawable (*fn_glXGetCurrentReadDrawableSGI_ptr)(void);
static fn_glXGetCurrentReadDrawableSGI_ptr __real_glXGetCurrentReadDrawableSGI;
static glvnd_mutex_t __mutex_glXGetCurrentReadDrawableSGI = GLVND_MUTEX_INITIALIZER;
PUBLIC GLXDrawable glXGetCurrentReadDrawableSGI(void)
{
    fn_glXGetCurrentReadDrawableSGI_ptr _real = (fn_glXGetCurrentReadDrawableSGI_ptr) LOAD_GLX_FUNC(glXGetCurrentReadDrawableSGI);
    if(_real != NULL) {
        return _real();
    } else {
        return None;
    }
}

typedef const char * (*fn_glXGetDriverConfig_ptr)(const char *driverName);
static fn_glXGetDriverConfig_ptr __real_glXGetDriverConfig;
static glvnd_mutex_t __mutex_glXGetDriverConfig = GLVND_MUTEX_INITIALIZER;
PUBLIC const char * glXGetDriverConfig(const char *driverName)
{
    fn_glXGetDriverConfig_ptr _real = (fn_glXGetDriverConfig_ptr) LOAD_GLX_FUNC(glXGetDriverConfig);
    if(_real != NULL) {
        return _real(driverName);
    } else {
        return NULL;
    }
}

PUBLIC int glXGetFBConfigAttrib(Display *dpy, GLXFBConfig config, int attribute, int *value)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXGetFBConfigAttrib(dpy, config, attribute, value);
}

typedef int (*fn_glXGetFBConfigAttribSGIX_ptr)(Display *dpy, GLXFBConfigSGIX config, int attribute, int *value);
static fn_glXGetFBConfigAttribSGIX_ptr __real_glXGetFBConfigAttribSGIX;
static glvnd_mutex_t __mutex_glXGetFBConfigAttribSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXGetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config, int attribute, int *value)
{
    fn_glXGetFBConfigAttribSGIX_ptr _real = (fn_glXGetFBConfigAttribSGIX_ptr) LOAD_GLX_FUNC(glXGetFBConfigAttribSGIX);
    if(_real != NULL) {
        return _real(dpy, config, attribute, value);
    } else {
        return 0;
    }
}

typedef GLXFBConfigSGIX (*fn_glXGetFBConfigFromVisualSGIX_ptr)(Display *dpy, XVisualInfo *vis);
static fn_glXGetFBConfigFromVisualSGIX_ptr __real_glXGetFBConfigFromVisualSGIX;
static glvnd_mutex_t __mutex_glXGetFBConfigFromVisualSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC GLXFBConfigSGIX glXGetFBConfigFromVisualSGIX(Display *dpy, XVisualInfo *vis)
{
    fn_glXGetFBConfigFromVisualSGIX_ptr _real = (fn_glXGetFBConfigFromVisualSGIX_ptr) LOAD_GLX_FUNC(glXGetFBConfigFromVisualSGIX);
    if(_real != NULL) {
        return _real(dpy, vis);
    } else {
        return NULL;
    }
}

PUBLIC GLXFBConfig * glXGetFBConfigs(Display *dpy, int screen, int *nelements)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXGetFBConfigs(dpy, screen, nelements);
}

typedef unsigned int (*fn_glXGetGPUIDsAMD_ptr)(unsigned int maxCount, unsigned int *ids);
static fn_glXGetGPUIDsAMD_ptr __real_glXGetGPUIDsAMD;
static glvnd_mutex_t __mutex_glXGetGPUIDsAMD = GLVND_MUTEX_INITIALIZER;
PUBLIC unsigned int glXGetGPUIDsAMD(unsigned int maxCount, unsigned int *ids)
{
    fn_glXGetGPUIDsAMD_ptr _real = (fn_glXGetGPUIDsAMD_ptr) LOAD_GLX_FUNC(glXGetGPUIDsAMD);
    if(_real != NULL) {
        return _real(maxCount, ids);
    } else {
        return 0;
    }
}

typedef int (*fn_glXGetGPUInfoAMD_ptr)(unsigned int id, int property, GLenum dataType, unsigned int size, void *data);
static fn_glXGetGPUInfoAMD_ptr __real_glXGetGPUInfoAMD;
static glvnd_mutex_t __mutex_glXGetGPUInfoAMD = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXGetGPUInfoAMD(unsigned int id, int property, GLenum dataType, unsigned int size, void *data)
{
    fn_glXGetGPUInfoAMD_ptr _real = (fn_glXGetGPUInfoAMD_ptr) LOAD_GLX_FUNC(glXGetGPUInfoAMD);
    if(_real != NULL) {
        return _real(id, property, dataType, size, data);
    } else {
        return 0;
    }
}

typedef Bool (*fn_glXGetMscRateOML_ptr)(Display *dpy, GLXDrawable drawable, int32_t *numerator, int32_t *denominator);
static fn_glXGetMscRateOML_ptr __real_glXGetMscRateOML;
static glvnd_mutex_t __mutex_glXGetMscRateOML = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXGetMscRateOML(Display *dpy, GLXDrawable drawable, int32_t *numerator, int32_t *denominator)
{
    fn_glXGetMscRateOML_ptr _real = (fn_glXGetMscRateOML_ptr) LOAD_GLX_FUNC(glXGetMscRateOML);
    if(_real != NULL) {
        return _real(dpy, drawable, numerator, denominator);
    } else {
        return False;
    }
}

PUBLIC __GLXextFuncPtr glXGetProcAddress(const GLubyte *procName)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXGetProcAddress(procName);
}

PUBLIC __GLXextFuncPtr glXGetProcAddressARB(const GLubyte *procName)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXGetProcAddressARB(procName);
}

typedef int (*fn_glXGetRefreshRateSGI_ptr)(unsigned int *rate);
static fn_glXGetRefreshRateSGI_ptr __real_glXGetRefreshRateSGI;
static glvnd_mutex_t __mutex_glXGetRefreshRateSGI = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXGetRefreshRateSGI(unsigned int *rate)
{
    fn_glXGetRefreshRateSGI_ptr _real = (fn_glXGetRefreshRateSGI_ptr) LOAD_GLX_FUNC(glXGetRefreshRateSGI);
    if(_real != NULL) {
        return _real(rate);
    } else {
        return 0;
    }
}

typedef const char * (*fn_glXGetScreenDriver_ptr)(Display *dpy, int scrNum);
static fn_glXGetScreenDriver_ptr __real_glXGetScreenDriver;
static glvnd_mutex_t __mutex_glXGetScreenDriver = GLVND_MUTEX_INITIALIZER;
PUBLIC const char * glXGetScreenDriver(Display *dpy, int scrNum)
{
    fn_glXGetScreenDriver_ptr _real = (fn_glXGetScreenDriver_ptr) LOAD_GLX_FUNC(glXGetScreenDriver);
    if(_real != NULL) {
        return _real(dpy, scrNum);
    } else {
        return NULL;
    }
}

PUBLIC void glXGetSelectedEvent(Display *dpy, GLXDrawable draw, unsigned long *event_mask)
{
    __GLXGL_CORE_FUNCTIONS.ptr_glXGetSelectedEvent(dpy, draw, event_mask);
}

typedef void (*fn_glXGetSelectedEventSGIX_ptr)(Display *dpy, GLXDrawable drawable, unsigned long *mask);
static fn_glXGetSelectedEventSGIX_ptr __real_glXGetSelectedEventSGIX;
static glvnd_mutex_t __mutex_glXGetSelectedEventSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXGetSelectedEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long *mask)
{
    fn_glXGetSelectedEventSGIX_ptr _real = (fn_glXGetSelectedEventSGIX_ptr) LOAD_GLX_FUNC(glXGetSelectedEventSGIX);
    if(_real != NULL) {
        _real(dpy, drawable, mask);
    }
}

typedef int (*fn_glXGetSwapIntervalMESA_ptr)(void);
static fn_glXGetSwapIntervalMESA_ptr __real_glXGetSwapIntervalMESA;
static glvnd_mutex_t __mutex_glXGetSwapIntervalMESA = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXGetSwapIntervalMESA(void)
{
    fn_glXGetSwapIntervalMESA_ptr _real = (fn_glXGetSwapIntervalMESA_ptr) LOAD_GLX_FUNC(glXGetSwapIntervalMESA);
    if(_real != NULL) {
        return _real();
    } else {
        return 0;
    }
}

typedef Bool (*fn_glXGetSyncValuesOML_ptr)(Display *dpy, GLXDrawable drawable, int64_t *ust, int64_t *msc, int64_t *sbc);
static fn_glXGetSyncValuesOML_ptr __real_glXGetSyncValuesOML;
static glvnd_mutex_t __mutex_glXGetSyncValuesOML = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXGetSyncValuesOML(Display *dpy, GLXDrawable drawable, int64_t *ust, int64_t *msc, int64_t *sbc)
{
    fn_glXGetSyncValuesOML_ptr _real = (fn_glXGetSyncValuesOML_ptr) LOAD_GLX_FUNC(glXGetSyncValuesOML);
    if(_real != NULL) {
        return _real(dpy, drawable, ust, msc, sbc);
    } else {
        return False;
    }
}

typedef Status (*fn_glXGetTransparentIndexSUN_ptr)(Display *dpy, Window overlay, Window underlay, unsigned long *pTransparentIndex);
static fn_glXGetTransparentIndexSUN_ptr __real_glXGetTransparentIndexSUN;
static glvnd_mutex_t __mutex_glXGetTransparentIndexSUN = GLVND_MUTEX_INITIALIZER;
PUBLIC Status glXGetTransparentIndexSUN(Display *dpy, Window overlay, Window underlay, unsigned long *pTransparentIndex)
{
    fn_glXGetTransparentIndexSUN_ptr _real = (fn_glXGetTransparentIndexSUN_ptr) LOAD_GLX_FUNC(glXGetTransparentIndexSUN);
    if(_real != NULL) {
        return _real(dpy, overlay, underlay, pTransparentIndex);
    } else {
        return 0;
    }
}

typedef int (*fn_glXGetVideoDeviceNV_ptr)(Display *dpy, int screen, int numVideoDevices, GLXVideoDeviceNV *pVideoDevice);
static fn_glXGetVideoDeviceNV_ptr __real_glXGetVideoDeviceNV;
static glvnd_mutex_t __mutex_glXGetVideoDeviceNV = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXGetVideoDeviceNV(Display *dpy, int screen, int numVideoDevices, GLXVideoDeviceNV *pVideoDevice)
{
    fn_glXGetVideoDeviceNV_ptr _real = (fn_glXGetVideoDeviceNV_ptr) LOAD_GLX_FUNC(glXGetVideoDeviceNV);
    if(_real != NULL) {
        return _real(dpy, screen, numVideoDevices, pVideoDevice);
    } else {
        return 0;
    }
}

typedef int (*fn_glXGetVideoInfoNV_ptr)(Display *dpy, int screen, GLXVideoDeviceNV VideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo);
static fn_glXGetVideoInfoNV_ptr __real_glXGetVideoInfoNV;
static glvnd_mutex_t __mutex_glXGetVideoInfoNV = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXGetVideoInfoNV(Display *dpy, int screen, GLXVideoDeviceNV VideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo)
{
    fn_glXGetVideoInfoNV_ptr _real = (fn_glXGetVideoInfoNV_ptr) LOAD_GLX_FUNC(glXGetVideoInfoNV);
    if(_real != NULL) {
        return _real(dpy, screen, VideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo);
    } else {
        return 0;
    }
}

typedef int (*fn_glXGetVideoSyncSGI_ptr)(unsigned int *count);
static fn_glXGetVideoSyncSGI_ptr __real_glXGetVideoSyncSGI;
static glvnd_mutex_t __mutex_glXGetVideoSyncSGI = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXGetVideoSyncSGI(unsigned int *count)
{
    fn_glXGetVideoSyncSGI_ptr _real = (fn_glXGetVideoSyncSGI_ptr) LOAD_GLX_FUNC(glXGetVideoSyncSGI);
    if(_real != NULL) {
        return _real(count);
    } else {
        return 0;
    }
}

PUBLIC XVisualInfo * glXGetVisualFromFBConfig(Display *dpy, GLXFBConfig config)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXGetVisualFromFBConfig(dpy, config);
}

typedef XVisualInfo * (*fn_glXGetVisualFromFBConfigSGIX_ptr)(Display *dpy, GLXFBConfigSGIX config);
static fn_glXGetVisualFromFBConfigSGIX_ptr __real_glXGetVisualFromFBConfigSGIX;
static glvnd_mutex_t __mutex_glXGetVisualFromFBConfigSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC XVisualInfo * glXGetVisualFromFBConfigSGIX(Display *dpy, GLXFBConfigSGIX config)
{
    fn_glXGetVisualFromFBConfigSGIX_ptr _real = (fn_glXGetVisualFromFBConfigSGIX_ptr) LOAD_GLX_FUNC(glXGetVisualFromFBConfigSGIX);
    if(_real != NULL) {
        return _real(dpy, config);
    } else {
        return NULL;
    }
}

typedef int (*fn_glXHyperpipeAttribSGIX_ptr)(Display *dpy, int timeSlice, int attrib, int size, void *attribList);
static fn_glXHyperpipeAttribSGIX_ptr __real_glXHyperpipeAttribSGIX;
static glvnd_mutex_t __mutex_glXHyperpipeAttribSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXHyperpipeAttribSGIX(Display *dpy, int timeSlice, int attrib, int size, void *attribList)
{
    fn_glXHyperpipeAttribSGIX_ptr _real = (fn_glXHyperpipeAttribSGIX_ptr) LOAD_GLX_FUNC(glXHyperpipeAttribSGIX);
    if(_real != NULL) {
        return _real(dpy, timeSlice, attrib, size, attribList);
    } else {
        return 0;
    }
}

typedef int (*fn_glXHyperpipeConfigSGIX_ptr)(Display *dpy, int networkId, int npipes, GLXHyperpipeConfigSGIX *cfg, int *hpId);
static fn_glXHyperpipeConfigSGIX_ptr __real_glXHyperpipeConfigSGIX;
static glvnd_mutex_t __mutex_glXHyperpipeConfigSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXHyperpipeConfigSGIX(Display *dpy, int networkId, int npipes, GLXHyperpipeConfigSGIX *cfg, int *hpId)
{
    fn_glXHyperpipeConfigSGIX_ptr _real = (fn_glXHyperpipeConfigSGIX_ptr) LOAD_GLX_FUNC(glXHyperpipeConfigSGIX);
    if(_real != NULL) {
        return _real(dpy, networkId, npipes, cfg, hpId);
    } else {
        return 0;
    }
}

typedef GLXContext (*fn_glXImportContextEXT_ptr)(Display *dpy, GLXContextID contextID);
static fn_glXImportContextEXT_ptr __real_glXImportContextEXT;
static glvnd_mutex_t __mutex_glXImportContextEXT = GLVND_MUTEX_INITIALIZER;
PUBLIC GLXContext glXImportContextEXT(Display *dpy, GLXContextID contextID)
{
    fn_glXImportContextEXT_ptr _real = (fn_glXImportContextEXT_ptr) LOAD_GLX_FUNC(glXImportContextEXT);
    if(_real != NULL) {
        return _real(dpy, contextID);
    } else {
        return NULL;
    }
}

PUBLIC Bool glXIsDirect(Display *dpy, GLXContext ctx)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXIsDirect(dpy, ctx);
}

typedef Bool (*fn_glXJoinSwapGroupNV_ptr)(Display *dpy, GLXDrawable drawable, GLuint group);
static fn_glXJoinSwapGroupNV_ptr __real_glXJoinSwapGroupNV;
static glvnd_mutex_t __mutex_glXJoinSwapGroupNV = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXJoinSwapGroupNV(Display *dpy, GLXDrawable drawable, GLuint group)
{
    fn_glXJoinSwapGroupNV_ptr _real = (fn_glXJoinSwapGroupNV_ptr) LOAD_GLX_FUNC(glXJoinSwapGroupNV);
    if(_real != NULL) {
        return _real(dpy, drawable, group);
    } else {
        return False;
    }
}

typedef void (*fn_glXJoinSwapGroupSGIX_ptr)(Display *dpy, GLXDrawable drawable, GLXDrawable member);
static fn_glXJoinSwapGroupSGIX_ptr __real_glXJoinSwapGroupSGIX;
static glvnd_mutex_t __mutex_glXJoinSwapGroupSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXJoinSwapGroupSGIX(Display *dpy, GLXDrawable drawable, GLXDrawable member)
{
    fn_glXJoinSwapGroupSGIX_ptr _real = (fn_glXJoinSwapGroupSGIX_ptr) LOAD_GLX_FUNC(glXJoinSwapGroupSGIX);
    if(_real != NULL) {
        _real(dpy, drawable, member);
    }
}

typedef void (*fn_glXLockVideoCaptureDeviceNV_ptr)(Display *dpy, GLXVideoCaptureDeviceNV device);
static fn_glXLockVideoCaptureDeviceNV_ptr __real_glXLockVideoCaptureDeviceNV;
static glvnd_mutex_t __mutex_glXLockVideoCaptureDeviceNV = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXLockVideoCaptureDeviceNV(Display *dpy, GLXVideoCaptureDeviceNV device)
{
    fn_glXLockVideoCaptureDeviceNV_ptr _real = (fn_glXLockVideoCaptureDeviceNV_ptr) LOAD_GLX_FUNC(glXLockVideoCaptureDeviceNV);
    if(_real != NULL) {
        _real(dpy, device);
    }
}

typedef Bool (*fn_glXMakeAssociatedContextCurrentAMD_ptr)(GLXContext ctx);
static fn_glXMakeAssociatedContextCurrentAMD_ptr __real_glXMakeAssociatedContextCurrentAMD;
static glvnd_mutex_t __mutex_glXMakeAssociatedContextCurrentAMD = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXMakeAssociatedContextCurrentAMD(GLXContext ctx)
{
    fn_glXMakeAssociatedContextCurrentAMD_ptr _real = (fn_glXMakeAssociatedContextCurrentAMD_ptr) LOAD_GLX_FUNC(glXMakeAssociatedContextCurrentAMD);
    if(_real != NULL) {
        return _real(ctx);
    } else {
        return False;
    }
}

PUBLIC Bool glXMakeContextCurrent(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXMakeContextCurrent(dpy, draw, read, ctx);
}

PUBLIC Bool glXMakeCurrent(Display *dpy, GLXDrawable drawable, GLXContext ctx)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXMakeCurrent(dpy, drawable, ctx);
}

typedef Bool (*fn_glXMakeCurrentReadSGI_ptr)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
static fn_glXMakeCurrentReadSGI_ptr __real_glXMakeCurrentReadSGI;
static glvnd_mutex_t __mutex_glXMakeCurrentReadSGI = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXMakeCurrentReadSGI(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx)
{
    fn_glXMakeCurrentReadSGI_ptr _real = (fn_glXMakeCurrentReadSGI_ptr) LOAD_GLX_FUNC(glXMakeCurrentReadSGI);
    if(_real != NULL) {
        return _real(dpy, draw, read, ctx);
    } else {
        return False;
    }
}

typedef void (*fn_glXNamedCopyBufferSubDataNV_ptr)(Display *dpy, GLXContext readCtx, GLXContext writeCtx, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
static fn_glXNamedCopyBufferSubDataNV_ptr __real_glXNamedCopyBufferSubDataNV;
static glvnd_mutex_t __mutex_glXNamedCopyBufferSubDataNV = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXNamedCopyBufferSubDataNV(Display *dpy, GLXContext readCtx, GLXContext writeCtx, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
    fn_glXNamedCopyBufferSubDataNV_ptr _real = (fn_glXNamedCopyBufferSubDataNV_ptr) LOAD_GLX_FUNC(glXNamedCopyBufferSubDataNV);
    if(_real != NULL) {
        _real(dpy, readCtx, writeCtx, readBuffer, writeBuffer, readOffset, writeOffset, size);
    }
}

typedef int (*fn_glXQueryChannelDeltasSGIX_ptr)(Display *display, int screen, int channel, int *x, int *y, int *w, int *h);
static fn_glXQueryChannelDeltasSGIX_ptr __real_glXQueryChannelDeltasSGIX;
static glvnd_mutex_t __mutex_glXQueryChannelDeltasSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXQueryChannelDeltasSGIX(Display *display, int screen, int channel, int *x, int *y, int *w, int *h)
{
    fn_glXQueryChannelDeltasSGIX_ptr _real = (fn_glXQueryChannelDeltasSGIX_ptr) LOAD_GLX_FUNC(glXQueryChannelDeltasSGIX);
    if(_real != NULL) {
        return _real(display, screen, channel, x, y, w, h);
    } else {
        return 0;
    }
}

typedef int (*fn_glXQueryChannelRectSGIX_ptr)(Display *display, int screen, int channel, int *dx, int *dy, int *dw, int *dh);
static fn_glXQueryChannelRectSGIX_ptr __real_glXQueryChannelRectSGIX;
static glvnd_mutex_t __mutex_glXQueryChannelRectSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXQueryChannelRectSGIX(Display *display, int screen, int channel, int *dx, int *dy, int *dw, int *dh)
{
    fn_glXQueryChannelRectSGIX_ptr _real = (fn_glXQueryChannelRectSGIX_ptr) LOAD_GLX_FUNC(glXQueryChannelRectSGIX);
    if(_real != NULL) {
        return _real(display, screen, channel, dx, dy, dw, dh);
    } else {
        return 0;
    }
}

PUBLIC int glXQueryContext(Display *dpy, GLXContext ctx, int attribute, int *value)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXQueryContext(dpy, ctx, attribute, value);
}

typedef int (*fn_glXQueryContextInfoEXT_ptr)(Display *dpy, GLXContext context, int attribute, int *value);
static fn_glXQueryContextInfoEXT_ptr __real_glXQueryContextInfoEXT;
static glvnd_mutex_t __mutex_glXQueryContextInfoEXT = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXQueryContextInfoEXT(Display *dpy, GLXContext context, int attribute, int *value)
{
    fn_glXQueryContextInfoEXT_ptr _real = (fn_glXQueryContextInfoEXT_ptr) LOAD_GLX_FUNC(glXQueryContextInfoEXT);
    if(_real != NULL) {
        return _real(dpy, context, attribute, value);
    } else {
        return 0;
    }
}

typedef Bool (*fn_glXQueryCurrentRendererIntegerMESA_ptr)(int attribute, unsigned int *value);
static fn_glXQueryCurrentRendererIntegerMESA_ptr __real_glXQueryCurrentRendererIntegerMESA;
static glvnd_mutex_t __mutex_glXQueryCurrentRendererIntegerMESA = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXQueryCurrentRendererIntegerMESA(int attribute, unsigned int *value)
{
    fn_glXQueryCurrentRendererIntegerMESA_ptr _real = (fn_glXQueryCurrentRendererIntegerMESA_ptr) LOAD_GLX_FUNC(glXQueryCurrentRendererIntegerMESA);
    if(_real != NULL) {
        return _real(attribute, value);
    } else {
        return False;
    }
}

typedef const char * (*fn_glXQueryCurrentRendererStringMESA_ptr)(int attribute);
static fn_glXQueryCurrentRendererStringMESA_ptr __real_glXQueryCurrentRendererStringMESA;
static glvnd_mutex_t __mutex_glXQueryCurrentRendererStringMESA = GLVND_MUTEX_INITIALIZER;
PUBLIC const char * glXQueryCurrentRendererStringMESA(int attribute)
{
    fn_glXQueryCurrentRendererStringMESA_ptr _real = (fn_glXQueryCurrentRendererStringMESA_ptr) LOAD_GLX_FUNC(glXQueryCurrentRendererStringMESA);
    if(_real != NULL) {
        return _real(attribute);
    } else {
        return NULL;
    }
}

PUBLIC void glXQueryDrawable(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value)
{
    __GLXGL_CORE_FUNCTIONS.ptr_glXQueryDrawable(dpy, draw, attribute, value);
}

PUBLIC Bool glXQueryExtension(Display *dpy, int *errorb, int *event)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXQueryExtension(dpy, errorb, event);
}

PUBLIC const char * glXQueryExtensionsString(Display *dpy, int screen)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXQueryExtensionsString(dpy, screen);
}

typedef Bool (*fn_glXQueryFrameCountNV_ptr)(Display *dpy, int screen, GLuint *count);
static fn_glXQueryFrameCountNV_ptr __real_glXQueryFrameCountNV;
static glvnd_mutex_t __mutex_glXQueryFrameCountNV = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXQueryFrameCountNV(Display *dpy, int screen, GLuint *count)
{
    fn_glXQueryFrameCountNV_ptr _real = (fn_glXQueryFrameCountNV_ptr) LOAD_GLX_FUNC(glXQueryFrameCountNV);
    if(_real != NULL) {
        return _real(dpy, screen, count);
    } else {
        return False;
    }
}

typedef void (*fn_glXQueryGLXPbufferSGIX_ptr)(Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value);
static fn_glXQueryGLXPbufferSGIX_ptr __real_glXQueryGLXPbufferSGIX;
static glvnd_mutex_t __mutex_glXQueryGLXPbufferSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXQueryGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value)
{
    fn_glXQueryGLXPbufferSGIX_ptr _real = (fn_glXQueryGLXPbufferSGIX_ptr) LOAD_GLX_FUNC(glXQueryGLXPbufferSGIX);
    if(_real != NULL) {
        _real(dpy, pbuf, attribute, value);
    }
}

typedef int (*fn_glXQueryHyperpipeAttribSGIX_ptr)(Display *dpy, int timeSlice, int attrib, int size, void *returnAttribList);
static fn_glXQueryHyperpipeAttribSGIX_ptr __real_glXQueryHyperpipeAttribSGIX;
static glvnd_mutex_t __mutex_glXQueryHyperpipeAttribSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXQueryHyperpipeAttribSGIX(Display *dpy, int timeSlice, int attrib, int size, void *returnAttribList)
{
    fn_glXQueryHyperpipeAttribSGIX_ptr _real = (fn_glXQueryHyperpipeAttribSGIX_ptr) LOAD_GLX_FUNC(glXQueryHyperpipeAttribSGIX);
    if(_real != NULL) {
        return _real(dpy, timeSlice, attrib, size, returnAttribList);
    } else {
        return 0;
    }
}

typedef int (*fn_glXQueryHyperpipeBestAttribSGIX_ptr)(Display *dpy, int timeSlice, int attrib, int size, void *attribList, void *returnAttribList);
static fn_glXQueryHyperpipeBestAttribSGIX_ptr __real_glXQueryHyperpipeBestAttribSGIX;
static glvnd_mutex_t __mutex_glXQueryHyperpipeBestAttribSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXQueryHyperpipeBestAttribSGIX(Display *dpy, int timeSlice, int attrib, int size, void *attribList, void *returnAttribList)
{
    fn_glXQueryHyperpipeBestAttribSGIX_ptr _real = (fn_glXQueryHyperpipeBestAttribSGIX_ptr) LOAD_GLX_FUNC(glXQueryHyperpipeBestAttribSGIX);
    if(_real != NULL) {
        return _real(dpy, timeSlice, attrib, size, attribList, returnAttribList);
    } else {
        return 0;
    }
}

typedef GLXHyperpipeConfigSGIX * (*fn_glXQueryHyperpipeConfigSGIX_ptr)(Display *dpy, int hpId, int *npipes);
static fn_glXQueryHyperpipeConfigSGIX_ptr __real_glXQueryHyperpipeConfigSGIX;
static glvnd_mutex_t __mutex_glXQueryHyperpipeConfigSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC GLXHyperpipeConfigSGIX * glXQueryHyperpipeConfigSGIX(Display *dpy, int hpId, int *npipes)
{
    fn_glXQueryHyperpipeConfigSGIX_ptr _real = (fn_glXQueryHyperpipeConfigSGIX_ptr) LOAD_GLX_FUNC(glXQueryHyperpipeConfigSGIX);
    if(_real != NULL) {
        return _real(dpy, hpId, npipes);
    } else {
        return NULL;
    }
}

typedef GLXHyperpipeNetworkSGIX * (*fn_glXQueryHyperpipeNetworkSGIX_ptr)(Display *dpy, int *npipes);
static fn_glXQueryHyperpipeNetworkSGIX_ptr __real_glXQueryHyperpipeNetworkSGIX;
static glvnd_mutex_t __mutex_glXQueryHyperpipeNetworkSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC GLXHyperpipeNetworkSGIX * glXQueryHyperpipeNetworkSGIX(Display *dpy, int *npipes)
{
    fn_glXQueryHyperpipeNetworkSGIX_ptr _real = (fn_glXQueryHyperpipeNetworkSGIX_ptr) LOAD_GLX_FUNC(glXQueryHyperpipeNetworkSGIX);
    if(_real != NULL) {
        return _real(dpy, npipes);
    } else {
        return NULL;
    }
}

typedef Bool (*fn_glXQueryMaxSwapBarriersSGIX_ptr)(Display *dpy, int screen, int *max);
static fn_glXQueryMaxSwapBarriersSGIX_ptr __real_glXQueryMaxSwapBarriersSGIX;
static glvnd_mutex_t __mutex_glXQueryMaxSwapBarriersSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXQueryMaxSwapBarriersSGIX(Display *dpy, int screen, int *max)
{
    fn_glXQueryMaxSwapBarriersSGIX_ptr _real = (fn_glXQueryMaxSwapBarriersSGIX_ptr) LOAD_GLX_FUNC(glXQueryMaxSwapBarriersSGIX);
    if(_real != NULL) {
        return _real(dpy, screen, max);
    } else {
        return False;
    }
}

typedef Bool (*fn_glXQueryMaxSwapGroupsNV_ptr)(Display *dpy, int screen, GLuint *maxGroups, GLuint *maxBarriers);
static fn_glXQueryMaxSwapGroupsNV_ptr __real_glXQueryMaxSwapGroupsNV;
static glvnd_mutex_t __mutex_glXQueryMaxSwapGroupsNV = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXQueryMaxSwapGroupsNV(Display *dpy, int screen, GLuint *maxGroups, GLuint *maxBarriers)
{
    fn_glXQueryMaxSwapGroupsNV_ptr _real = (fn_glXQueryMaxSwapGroupsNV_ptr) LOAD_GLX_FUNC(glXQueryMaxSwapGroupsNV);
    if(_real != NULL) {
        return _real(dpy, screen, maxGroups, maxBarriers);
    } else {
        return False;
    }
}

typedef Bool (*fn_glXQueryRendererIntegerMESA_ptr)(Display *dpy, int screen, int renderer, int attribute, unsigned int *value);
static fn_glXQueryRendererIntegerMESA_ptr __real_glXQueryRendererIntegerMESA;
static glvnd_mutex_t __mutex_glXQueryRendererIntegerMESA = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXQueryRendererIntegerMESA(Display *dpy, int screen, int renderer, int attribute, unsigned int *value)
{
    fn_glXQueryRendererIntegerMESA_ptr _real = (fn_glXQueryRendererIntegerMESA_ptr) LOAD_GLX_FUNC(glXQueryRendererIntegerMESA);
    if(_real != NULL) {
        return _real(dpy, screen, renderer, attribute, value);
    } else {
        return False;
    }
}

typedef const char * (*fn_glXQueryRendererStringMESA_ptr)(Display *dpy, int screen, int renderer, int attribute);
static fn_glXQueryRendererStringMESA_ptr __real_glXQueryRendererStringMESA;
static glvnd_mutex_t __mutex_glXQueryRendererStringMESA = GLVND_MUTEX_INITIALIZER;
PUBLIC const char * glXQueryRendererStringMESA(Display *dpy, int screen, int renderer, int attribute)
{
    fn_glXQueryRendererStringMESA_ptr _real = (fn_glXQueryRendererStringMESA_ptr) LOAD_GLX_FUNC(glXQueryRendererStringMESA);
    if(_real != NULL) {
        return _real(dpy, screen, renderer, attribute);
    } else {
        return NULL;
    }
}

PUBLIC const char * glXQueryServerString(Display *dpy, int screen, int name)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXQueryServerString(dpy, screen, name);
}

typedef Bool (*fn_glXQuerySwapGroupNV_ptr)(Display *dpy, GLXDrawable drawable, GLuint *group, GLuint *barrier);
static fn_glXQuerySwapGroupNV_ptr __real_glXQuerySwapGroupNV;
static glvnd_mutex_t __mutex_glXQuerySwapGroupNV = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXQuerySwapGroupNV(Display *dpy, GLXDrawable drawable, GLuint *group, GLuint *barrier)
{
    fn_glXQuerySwapGroupNV_ptr _real = (fn_glXQuerySwapGroupNV_ptr) LOAD_GLX_FUNC(glXQuerySwapGroupNV);
    if(_real != NULL) {
        return _real(dpy, drawable, group, barrier);
    } else {
        return False;
    }
}

PUBLIC Bool glXQueryVersion(Display *dpy, int *maj, int *min)
{
    return __GLXGL_CORE_FUNCTIONS.ptr_glXQueryVersion(dpy, maj, min);
}

typedef int (*fn_glXQueryVideoCaptureDeviceNV_ptr)(Display *dpy, GLXVideoCaptureDeviceNV device, int attribute, int *value);
static fn_glXQueryVideoCaptureDeviceNV_ptr __real_glXQueryVideoCaptureDeviceNV;
static glvnd_mutex_t __mutex_glXQueryVideoCaptureDeviceNV = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXQueryVideoCaptureDeviceNV(Display *dpy, GLXVideoCaptureDeviceNV device, int attribute, int *value)
{
    fn_glXQueryVideoCaptureDeviceNV_ptr _real = (fn_glXQueryVideoCaptureDeviceNV_ptr) LOAD_GLX_FUNC(glXQueryVideoCaptureDeviceNV);
    if(_real != NULL) {
        return _real(dpy, device, attribute, value);
    } else {
        return 0;
    }
}

typedef Bool (*fn_glXReleaseBuffersMESA_ptr)(Display *dpy, GLXDrawable drawable);
static fn_glXReleaseBuffersMESA_ptr __real_glXReleaseBuffersMESA;
static glvnd_mutex_t __mutex_glXReleaseBuffersMESA = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXReleaseBuffersMESA(Display *dpy, GLXDrawable drawable)
{
    fn_glXReleaseBuffersMESA_ptr _real = (fn_glXReleaseBuffersMESA_ptr) LOAD_GLX_FUNC(glXReleaseBuffersMESA);
    if(_real != NULL) {
        return _real(dpy, drawable);
    } else {
        return False;
    }
}

typedef void (*fn_glXReleaseTexImageEXT_ptr)(Display *dpy, GLXDrawable drawable, int buffer);
static fn_glXReleaseTexImageEXT_ptr __real_glXReleaseTexImageEXT;
static glvnd_mutex_t __mutex_glXReleaseTexImageEXT = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXReleaseTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer)
{
    fn_glXReleaseTexImageEXT_ptr _real = (fn_glXReleaseTexImageEXT_ptr) LOAD_GLX_FUNC(glXReleaseTexImageEXT);
    if(_real != NULL) {
        _real(dpy, drawable, buffer);
    }
}

typedef void (*fn_glXReleaseVideoCaptureDeviceNV_ptr)(Display *dpy, GLXVideoCaptureDeviceNV device);
static fn_glXReleaseVideoCaptureDeviceNV_ptr __real_glXReleaseVideoCaptureDeviceNV;
static glvnd_mutex_t __mutex_glXReleaseVideoCaptureDeviceNV = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXReleaseVideoCaptureDeviceNV(Display *dpy, GLXVideoCaptureDeviceNV device)
{
    fn_glXReleaseVideoCaptureDeviceNV_ptr _real = (fn_glXReleaseVideoCaptureDeviceNV_ptr) LOAD_GLX_FUNC(glXReleaseVideoCaptureDeviceNV);
    if(_real != NULL) {
        _real(dpy, device);
    }
}

typedef int (*fn_glXReleaseVideoDeviceNV_ptr)(Display *dpy, int screen, GLXVideoDeviceNV VideoDevice);
static fn_glXReleaseVideoDeviceNV_ptr __real_glXReleaseVideoDeviceNV;
static glvnd_mutex_t __mutex_glXReleaseVideoDeviceNV = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXReleaseVideoDeviceNV(Display *dpy, int screen, GLXVideoDeviceNV VideoDevice)
{
    fn_glXReleaseVideoDeviceNV_ptr _real = (fn_glXReleaseVideoDeviceNV_ptr) LOAD_GLX_FUNC(glXReleaseVideoDeviceNV);
    if(_real != NULL) {
        return _real(dpy, screen, VideoDevice);
    } else {
        return 0;
    }
}

typedef int (*fn_glXReleaseVideoImageNV_ptr)(Display *dpy, GLXPbuffer pbuf);
static fn_glXReleaseVideoImageNV_ptr __real_glXReleaseVideoImageNV;
static glvnd_mutex_t __mutex_glXReleaseVideoImageNV = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXReleaseVideoImageNV(Display *dpy, GLXPbuffer pbuf)
{
    fn_glXReleaseVideoImageNV_ptr _real = (fn_glXReleaseVideoImageNV_ptr) LOAD_GLX_FUNC(glXReleaseVideoImageNV);
    if(_real != NULL) {
        return _real(dpy, pbuf);
    } else {
        return 0;
    }
}

typedef Bool (*fn_glXResetFrameCountNV_ptr)(Display *dpy, int screen);
static fn_glXResetFrameCountNV_ptr __real_glXResetFrameCountNV;
static glvnd_mutex_t __mutex_glXResetFrameCountNV = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXResetFrameCountNV(Display *dpy, int screen)
{
    fn_glXResetFrameCountNV_ptr _real = (fn_glXResetFrameCountNV_ptr) LOAD_GLX_FUNC(glXResetFrameCountNV);
    if(_real != NULL) {
        return _real(dpy, screen);
    } else {
        return False;
    }
}

PUBLIC void glXSelectEvent(Display *dpy, GLXDrawable draw, unsigned long event_mask)
{
    __GLXGL_CORE_FUNCTIONS.ptr_glXSelectEvent(dpy, draw, event_mask);
}

typedef void (*fn_glXSelectEventSGIX_ptr)(Display *dpy, GLXDrawable drawable, unsigned long mask);
static fn_glXSelectEventSGIX_ptr __real_glXSelectEventSGIX;
static glvnd_mutex_t __mutex_glXSelectEventSGIX = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXSelectEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long mask)
{
    fn_glXSelectEventSGIX_ptr _real = (fn_glXSelectEventSGIX_ptr) LOAD_GLX_FUNC(glXSelectEventSGIX);
    if(_real != NULL) {
        _real(dpy, drawable, mask);
    }
}

typedef int (*fn_glXSendPbufferToVideoNV_ptr)(Display *dpy, GLXPbuffer pbuf, int iBufferType, unsigned long *pulCounterPbuffer, GLboolean bBlock);
static fn_glXSendPbufferToVideoNV_ptr __real_glXSendPbufferToVideoNV;
static glvnd_mutex_t __mutex_glXSendPbufferToVideoNV = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXSendPbufferToVideoNV(Display *dpy, GLXPbuffer pbuf, int iBufferType, unsigned long *pulCounterPbuffer, GLboolean bBlock)
{
    fn_glXSendPbufferToVideoNV_ptr _real = (fn_glXSendPbufferToVideoNV_ptr) LOAD_GLX_FUNC(glXSendPbufferToVideoNV);
    if(_real != NULL) {
        return _real(dpy, pbuf, iBufferType, pulCounterPbuffer, bBlock);
    } else {
        return 0;
    }
}

typedef GLboolean (*fn_glXSet3DfxModeMESA_ptr)(GLint mode);
static fn_glXSet3DfxModeMESA_ptr __real_glXSet3DfxModeMESA;
static glvnd_mutex_t __mutex_glXSet3DfxModeMESA = GLVND_MUTEX_INITIALIZER;
PUBLIC GLboolean glXSet3DfxModeMESA(GLint mode)
{
    fn_glXSet3DfxModeMESA_ptr _real = (fn_glXSet3DfxModeMESA_ptr) LOAD_GLX_FUNC(glXSet3DfxModeMESA);
    if(_real != NULL) {
        return _real(mode);
    } else {
        return 0;
    }
}

PUBLIC void glXSwapBuffers(Display *dpy, GLXDrawable drawable)
{
    __GLXGL_CORE_FUNCTIONS.ptr_glXSwapBuffers(dpy, drawable);
}

typedef int64_t (*fn_glXSwapBuffersMscOML_ptr)(Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder);
static fn_glXSwapBuffersMscOML_ptr __real_glXSwapBuffersMscOML;
static glvnd_mutex_t __mutex_glXSwapBuffersMscOML = GLVND_MUTEX_INITIALIZER;
PUBLIC int64_t glXSwapBuffersMscOML(Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder)
{
    fn_glXSwapBuffersMscOML_ptr _real = (fn_glXSwapBuffersMscOML_ptr) LOAD_GLX_FUNC(glXSwapBuffersMscOML);
    if(_real != NULL) {
        return _real(dpy, drawable, target_msc, divisor, remainder);
    } else {
        return 0;
    }
}

typedef void (*fn_glXSwapIntervalEXT_ptr)(Display *dpy, GLXDrawable drawable, int interval);
static fn_glXSwapIntervalEXT_ptr __real_glXSwapIntervalEXT;
static glvnd_mutex_t __mutex_glXSwapIntervalEXT = GLVND_MUTEX_INITIALIZER;
PUBLIC void glXSwapIntervalEXT(Display *dpy, GLXDrawable drawable, int interval)
{
    fn_glXSwapIntervalEXT_ptr _real = (fn_glXSwapIntervalEXT_ptr) LOAD_GLX_FUNC(glXSwapIntervalEXT);
    if(_real != NULL) {
        _real(dpy, drawable, interval);
    }
}

typedef int (*fn_glXSwapIntervalMESA_ptr)(unsigned int interval);
static fn_glXSwapIntervalMESA_ptr __real_glXSwapIntervalMESA;
static glvnd_mutex_t __mutex_glXSwapIntervalMESA = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXSwapIntervalMESA(unsigned int interval)
{
    fn_glXSwapIntervalMESA_ptr _real = (fn_glXSwapIntervalMESA_ptr) LOAD_GLX_FUNC(glXSwapIntervalMESA);
    if(_real != NULL) {
        return _real(interval);
    } else {
        return 0;
    }
}

typedef int (*fn_glXSwapIntervalSGI_ptr)(int interval);
static fn_glXSwapIntervalSGI_ptr __real_glXSwapIntervalSGI;
static glvnd_mutex_t __mutex_glXSwapIntervalSGI = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXSwapIntervalSGI(int interval)
{
    fn_glXSwapIntervalSGI_ptr _real = (fn_glXSwapIntervalSGI_ptr) LOAD_GLX_FUNC(glXSwapIntervalSGI);
    if(_real != NULL) {
        return _real(interval);
    } else {
        return 0;
    }
}

PUBLIC void glXUseXFont(Font font, int first, int count, int list)
{
    __GLXGL_CORE_FUNCTIONS.ptr_glXUseXFont(font, first, count, list);
}

typedef Bool (*fn_glXWaitForMscOML_ptr)(Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc);
static fn_glXWaitForMscOML_ptr __real_glXWaitForMscOML;
static glvnd_mutex_t __mutex_glXWaitForMscOML = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXWaitForMscOML(Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc)
{
    fn_glXWaitForMscOML_ptr _real = (fn_glXWaitForMscOML_ptr) LOAD_GLX_FUNC(glXWaitForMscOML);
    if(_real != NULL) {
        return _real(dpy, drawable, target_msc, divisor, remainder, ust, msc, sbc);
    } else {
        return False;
    }
}

typedef Bool (*fn_glXWaitForSbcOML_ptr)(Display *dpy, GLXDrawable drawable, int64_t target_sbc, int64_t *ust, int64_t *msc, int64_t *sbc);
static fn_glXWaitForSbcOML_ptr __real_glXWaitForSbcOML;
static glvnd_mutex_t __mutex_glXWaitForSbcOML = GLVND_MUTEX_INITIALIZER;
PUBLIC Bool glXWaitForSbcOML(Display *dpy, GLXDrawable drawable, int64_t target_sbc, int64_t *ust, int64_t *msc, int64_t *sbc)
{
    fn_glXWaitForSbcOML_ptr _real = (fn_glXWaitForSbcOML_ptr) LOAD_GLX_FUNC(glXWaitForSbcOML);
    if(_real != NULL) {
        return _real(dpy, drawable, target_sbc, ust, msc, sbc);
    } else {
        return False;
    }
}

PUBLIC void glXWaitGL(void)
{
    __GLXGL_CORE_FUNCTIONS.ptr_glXWaitGL();
}

typedef int (*fn_glXWaitVideoSyncSGI_ptr)(int divisor, int remainder, unsigned int *count);
static fn_glXWaitVideoSyncSGI_ptr __real_glXWaitVideoSyncSGI;
static glvnd_mutex_t __mutex_glXWaitVideoSyncSGI = GLVND_MUTEX_INITIALIZER;
PUBLIC int glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
{
    fn_glXWaitVideoSyncSGI_ptr _real = (fn_glXWaitVideoSyncSGI_ptr) LOAD_GLX_FUNC(glXWaitVideoSyncSGI);
    if(_real != NULL) {
        return _real(divisor, remainder, count);
    } else {
        return 0;
    }
}

PUBLIC void glXWaitX(void)
{
    __GLXGL_CORE_FUNCTIONS.ptr_glXWaitX();
}

